public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
jsonReader.Read();
object obj2 = this.JsonFormatReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, this.MemberNames);
jsonReader.ReadEndElement();
return obj2;
}
void ReadMembers(ClassDataContract classContract, ExtensionDataObject extensionData)
{
int memberCount = classContract.MemberNames.Length;
context.IncrementItemCount(memberCount);
int memberIndex = -1;
// JSON intrinsic part.
BitFlagsGenerator expectedElements = new BitFlagsGenerator(memberCount);
byte [] requiredElements = new byte [expectedElements.GetLocalCount()];
SetRequiredElements(classContract, requiredElements);
SetExpectedElements(expectedElements, 0 /*startIndex*/);
while (XmlObjectSerializerReadContext.MoveToNextElement(xmlReader))
{
int idx; // used as in "switch (idx)" in the original source.
idx = context.GetJsonMemberIndex(xmlReader, memberNames, memberIndex, extensionData);
if (memberCount > 0)
{
ReadMembers(idx, classContract, expectedElements, ref memberIndex);
}
}
if (!CheckRequiredElements(expectedElements, requiredElements))
{
XmlObjectSerializerReadContextComplexJson.ThrowMissingRequiredMembers(objectLocal, memberNames, expectedElements.LoadArray(), requiredElements);
}
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
string xmlContent = jsonReader.ReadElementContentAsString();
DataContractSerializer dataContractSerializer = new DataContractSerializer(TraditionalDataContract.UnderlyingType,
GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList), 1, false, false); // maxItemsInObjectGraph // ignoreExtensionDataObject // preserveObjectReferences
MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlContent));
object xmlValue;
XmlDictionaryReaderQuotas quotas = ((JsonReaderDelegator)jsonReader).ReaderQuotas;
if (quotas == null)
{
xmlValue = dataContractSerializer.ReadObject(memoryStream);
}
else
{
xmlValue = dataContractSerializer.ReadObject(XmlDictionaryReader.CreateTextReader(memoryStream, quotas));
}
if (context != null)
{
context.AddNewObject(xmlValue);
}
return(xmlValue);
}
public static object ConvertDictionaryToClassDataContract(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary<string, object> deserialzedValue, XmlObjectSerializerReadContextComplexJson context)
{
if (deserialzedValue == null)
{
return null;
}
if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
{
var tuple = deserialzedValue["DateTime"] as Tuple<DateTime, string>;
DateTimeOffset dto = new DateTimeOffset(tuple != null ? tuple.Item1 : (DateTime)deserialzedValue["DateTime"]);
return dto.ToOffset(new TimeSpan(0, (int)deserialzedValue["OffsetMinutes"], 0));
}
object serverTypeStringValue;
if (deserialzedValue.TryGetValue(JsonGlobals.ServerTypeString, out serverTypeStringValue))
{
dataContract = ResolveDataContractFromTypeInformation(serverTypeStringValue.ToString(), dataContract, context);
}
object o = CreateInstance(dataContract);
CheckDuplicateNames(dataContract);
DataContractJsonSerializer.InvokeOnDeserializing(o, dataContract, context);
ReadClassDataContractMembers(serializer, dataContract, deserialzedValue, o, context);
DataContractJsonSerializer.InvokeOnDeserialized(o, dataContract, context);
if (dataContract.IsKeyValuePairAdapter)
{
return dataContract.GetKeyValuePairMethodInfo.Invoke(o, Array.Empty<Type>());
}
return o;
}
public object ReadJsonValue(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
this.PushKnownDataContracts(context);
object obj2 = this.ReadJsonValueCore(jsonReader, context);
this.PopKnownDataContracts(context);
return obj2;
}
internal override object InternalReadObject(XmlReaderDelegator xmlReader, bool verifyObjectName)
{
if (this.MaxItemsInObjectGraph == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("ExceededMaxItemsQuota", new object[] { this.MaxItemsInObjectGraph })));
}
if (verifyObjectName)
{
if (!this.InternalIsStartObject(xmlReader))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(System.Runtime.Serialization.SR.GetString("ExpectingElement", new object[] { XmlDictionaryString.Empty, this.RootName }), xmlReader));
}
}
else if (!base.IsStartElement(xmlReader))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(System.Runtime.Serialization.SR.GetString("ExpectingElementAtDeserialize", new object[] { XmlNodeType.Element }), xmlReader));
}
DataContract rootContract = this.RootContract;
if (rootContract.IsPrimitive && object.ReferenceEquals(rootContract.UnderlyingType, this.rootType))
{
return(ReadJsonValue(rootContract, xmlReader, null));
}
return(XmlObjectSerializerReadContextComplexJson.CreateContext(this, rootContract).InternalDeserialize(xmlReader, this.rootType, rootContract, null, null));
}
public object ReadJsonValue(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
PushKnownDataContracts(context);
object deserializedObject = ReadJsonValueCore(jsonReader, context);
PopKnownDataContracts(context);
return deserializedObject;
}
int ReadMembers(int index, ClassDataContract classContract, BitFlagsGenerator expectedElements, ref int memberIndex)
{
int memberCount = (classContract.BaseContract == null) ? 0 : ReadMembers(index, classContract.BaseContract, expectedElements,
ref memberIndex);
if (memberCount <= index && index < memberCount + classContract.Members.Count)
{
DataMember dataMember = classContract.Members [index - memberCount];
Type memberType = dataMember.MemberType;
memberIndex = memberCount;
if (!expectedElements.Load(index))
{
XmlObjectSerializerReadContextComplexJson.ThrowDuplicateMemberException(objectLocal, memberNames, memberIndex);
}
if (dataMember.IsGetOnlyCollection)
{
var value = CodeInterpreter.GetMember(dataMember.MemberInfo, objectLocal);
context.StoreCollectionMemberInfo(value);
ReadValue(memberType, dataMember.Name);
}
else
{
var value = ReadValue(memberType, dataMember.Name);
CodeInterpreter.SetMember(dataMember.MemberInfo, objectLocal, value);
}
memberIndex = index;
ResetExpectedElements(expectedElements, index);
}
return(memberCount + classContract.Members.Count);
}
internal override object InternalReadObject(XmlReaderDelegator xmlReader, bool verifyObjectName)
{
if (MaxItemsInObjectGraph == 0)
{
throw XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ExceededMaxItemsQuota, MaxItemsInObjectGraph));
}
if (verifyObjectName)
{
if (!InternalIsStartObject(xmlReader))
{
throw XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.Format(SR.ExpectingElement, XmlDictionaryString.Empty, RootName), xmlReader);
}
}
else if (!IsStartElement(xmlReader))
{
throw XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.Format(SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader);
}
DataContract contract = RootContract;
if (contract.IsPrimitive && object.ReferenceEquals(contract.UnderlyingType, _rootType))// handle Nullable<T> differently
{
return(DataContractJsonSerializerImpl.ReadJsonValue(contract, xmlReader, null));
}
XmlObjectSerializerReadContextComplexJson context = XmlObjectSerializerReadContextComplexJson.CreateContext(this, contract);
return(context.InternalDeserialize(xmlReader, _rootType, contract, null, null));
}
public object ReadJsonValue(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
PushKnownDataContracts(context);
object deserializedObject = ReadJsonValueCore(jsonReader, context);
PopKnownDataContracts(context);
return(deserializedObject);
}
public object ReadJsonValue(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
this.PushKnownDataContracts(context);
object obj2 = this.ReadJsonValueCore(jsonReader, context);
this.PopKnownDataContracts(context);
return(obj2);
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
jsonReader.Read();
object o = JsonFormatReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, MemberNames);
jsonReader.ReadEndElement();
return(o);
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object obj2;
string attribute = jsonReader.GetAttribute("type");
string key = attribute;
if (key != null)
{
int num;
if (< PrivateImplementationDetails > { D290E7C2 - 4296 - 4D 66 - A436 - 0C17851A078B }.$$method0x60012be - 1.TryGetValue(key, out num))
internal static bool IsJsonLocalName(XmlReaderDelegator reader, string elementName)
{
string name;
if (XmlObjectSerializerReadContextComplexJson.TryGetJsonLocalName(reader, out name))
{
return(elementName == name);
}
return(false);
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
if (context == null)
{
return(TryReadNullAtTopLevel(jsonReader) ? null : jsonReader.ReadElementContentAsUri());
}
else
{
return(HandleReadValue(jsonReader.ReadElementContentAsUri(), context));
}
}
private static ClassDataContract ResolveDataContractFromTypeInformation(string typeName, DataContract contract, XmlObjectSerializerReadContextComplexJson context)
{
DataContract dataContract = context.ResolveDataContractFromType(typeName, Globals.DataContractXsdBaseNamespace, contract);
if (dataContract == null)
{
XmlQualifiedName qname = XmlObjectSerializerReadContextComplexJson.ParseQualifiedName(typeName);
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.DcTypeNotFoundOnDeserialize, qname.Namespace, qname.Name)));
}
return((ClassDataContract)dataContract);
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
if (context == null)
{
return TryReadNullAtTopLevel(jsonReader) ? null : jsonReader.ReadElementContentAsQName();
}
else
{
return HandleReadValue(jsonReader.ReadElementContentAsQName(), context);
}
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
if (context != null)
{
return JsonDataContract.HandleReadValue(jsonReader.ReadElementContentAsBase64(), context);
}
if (!JsonDataContract.TryReadNullAtTopLevel(jsonReader))
{
return jsonReader.ReadElementContentAsBase64();
}
return null;
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
if (context != null)
{
return(JsonDataContract.HandleReadValue(jsonReader.ReadElementContentAsUri(), context));
}
if (!JsonDataContract.TryReadNullAtTopLevel(jsonReader))
{
return(jsonReader.ReadElementContentAsUri());
}
return(null);
}
public void ReadGetOnlyCollectionFromJson(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContextComplexJson context, XmlDictionaryString emptyDictionaryString, XmlDictionaryString itemName, CollectionDataContract collectionContract)
{
#region GenerateCollectionReaderHelper
// InitArgs()
this.xmlReader = xmlReader;
this.context = context;
this.emptyDictionaryString = emptyDictionaryString;
this.itemName = itemName;
this.collectionContract = collectionContract;
#endregion
ReadGetOnlyCollection(collectionContract);
}
private static void ReadClassDataContractMembers(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary<string, object> deserialzedValue, object newInstance, XmlObjectSerializerReadContextComplexJson context)
{
if (dataContract.BaseContract != null)
{
ReadClassDataContractMembers(serializer, dataContract.BaseContract, deserialzedValue, newInstance, context);
}
for (int i = 0; i < dataContract.Members.Count; i++)
{
DataMember member = dataContract.Members[i];
object currentMemberValue;
if (deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name), out currentMemberValue) ||
dataContract.IsKeyValuePairAdapter && deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name.ToLowerInvariant()), out currentMemberValue))
{
if (member.MemberType.GetTypeInfo().IsPrimitive || currentMemberValue == null)
{
SetMemberValue(newInstance, serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context), dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
}
else
{
context.PushKnownTypes(dataContract);
object subMemberValue = serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context);
Type declaredType = (member.MemberType.GetTypeInfo().IsGenericType && member.MemberType.GetGenericTypeDefinition() == Globals.TypeOfNullable)
? Nullable.GetUnderlyingType(member.MemberType)
: member.MemberType;
if (!(declaredType == Globals.TypeOfObject && subMemberValue.GetType() == Globals.TypeOfObjectArray) && declaredType != subMemberValue.GetType())
{
DataContract memberValueContract = DataContract.GetDataContract(subMemberValue.GetType());
context.CheckIfTypeNeedsVerifcation(member.MemberTypeContract, memberValueContract);
}
if (member.IsGetOnlyCollection)
{
PopulateReadOnlyCollection(newInstance, member, (IEnumerable)subMemberValue);
}
else
{
SetMemberValue(newInstance, subMemberValue, dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
}
context.PopKnownTypes(dataContract);
}
}
else if (member.IsRequired)
{
XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(dataContract.MemberNames[i].Value, dataContract.UnderlyingType);
}
}
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object obj2;
string attribute = jsonReader.GetAttribute("type");
string key = attribute;
if (key != null)
{
int num;
if (<PrivateImplementationDetails>{D290E7C2-4296-4D66-A436-0C17851A078B}.$$method0x60012be-1.TryGetValue(key, out num))
{
switch (num)
{
case 0:
jsonReader.Skip();
obj2 = null;
goto Label_011B;
case 1:
obj2 = jsonReader.ReadElementContentAsBoolean();
goto Label_011B;
case 2:
goto Label_00BB;
case 3:
obj2 = ParseJsonNumber(jsonReader.ReadElementContentAsString());
goto Label_011B;
case 4:
jsonReader.Skip();
obj2 = new object();
goto Label_011B;
case 5:
return DataContractJsonSerializer.ReadJsonValue(DataContract.GetDataContract(Globals.TypeOfObjectArray), jsonReader, context);
}
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("JsonUnexpectedAttributeValue", new object[] { attribute })));
}
Label_00BB:
obj2 = jsonReader.ReadElementContentAsString();
Label_011B:
if (context != null)
{
context.AddNewObject(obj2);
}
return obj2;
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
jsonReader.Read();
object obj2 = null;
if (context.IsGetOnlyCollection)
{
context.IsGetOnlyCollection = false;
this.JsonFormatGetOnlyReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, JsonGlobals.itemDictionaryString, this.TraditionalCollectionDataContract);
}
else
{
obj2 = this.JsonFormatReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, JsonGlobals.itemDictionaryString, this.TraditionalCollectionDataContract);
}
jsonReader.ReadEndElement();
return obj2;
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
jsonReader.Read();
object obj2 = null;
if (context.IsGetOnlyCollection)
{
context.IsGetOnlyCollection = false;
this.JsonFormatGetOnlyReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, JsonGlobals.itemDictionaryString, this.TraditionalCollectionDataContract);
}
else
{
obj2 = this.JsonFormatReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, JsonGlobals.itemDictionaryString, this.TraditionalCollectionDataContract);
}
jsonReader.ReadEndElement();
return(obj2);
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
jsonReader.Read();
object o = null;
if (context.IsGetOnlyCollection)
{
// IsGetOnlyCollection value has already been used to create current collectiondatacontract, value can now be reset.
context.IsGetOnlyCollection = false;
JsonFormatGetOnlyReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, JsonGlobals.itemDictionaryString, TraditionalCollectionDataContract);
}
else
{
o = JsonFormatReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, JsonGlobals.itemDictionaryString, TraditionalCollectionDataContract);
}
jsonReader.ReadEndElement();
return o;
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object obj;
string contentMode = jsonReader.GetAttribute(JsonGlobals.typeString);
switch (contentMode)
{
case JsonGlobals.nullString:
jsonReader.Skip();
obj = null;
break;
case JsonGlobals.booleanString:
obj = jsonReader.ReadElementContentAsBoolean();
break;
case JsonGlobals.stringString:
case null:
obj = jsonReader.ReadElementContentAsString();
break;
case JsonGlobals.numberString:
obj = ParseJsonNumber(jsonReader.ReadElementContentAsString());
break;
case JsonGlobals.objectString:
jsonReader.Skip();
obj = new object();
break;
case JsonGlobals.arrayString:
// Read as object array
return(DataContractJsonSerializer.ReadJsonValue(DataContract.GetDataContract(Globals.TypeOfObjectArray), jsonReader, context));
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.JsonUnexpectedAttributeValue, contentMode)));
}
if (context != null)
{
context.AddNewObject(obj);
}
return(obj);
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object obj2;
if (this.IsULong)
{
obj2 = Enum.ToObject(base.TraditionalDataContract.UnderlyingType, jsonReader.ReadElementContentAsUnsignedLong());
}
else
{
obj2 = Enum.ToObject(base.TraditionalDataContract.UnderlyingType, jsonReader.ReadElementContentAsLong());
}
if (context != null)
{
context.AddNewObject(obj2);
}
return(obj2);
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object enumValue;
if (IsULong)
{
enumValue = Enum.ToObject(TraditionalDataContract.UnderlyingType, jsonReader.ReadElementContentAsUnsignedLong());
}
else
{
enumValue = Enum.ToObject(TraditionalDataContract.UnderlyingType, jsonReader.ReadElementContentAsLong());
}
if (context != null)
{
context.AddNewObject(enumValue);
}
return enumValue;
}
public object ReadFromJson(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContextComplexJson context, XmlDictionaryString emptyDictionaryString, XmlDictionaryString[] memberNames)
{
// InitArgs()
this.xmlReader = xmlReader;
this.context = context;
this.emptyDictionaryString = emptyDictionaryString;
this.memberNames = memberNames;
//DemandSerializationFormatterPermission(classContract);
//DemandMemberAccessPermission(memberAccessFlag);
CreateObject(classContract);
context.AddNewObject(objectLocal);
InvokeOnDeserializing(classContract);
string objectId = null;
if (classContract.IsISerializable)
{
ReadISerializable(classContract);
}
else
{
ReadClass(classContract);
}
if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom(classContract.UnderlyingType))
{
((IDeserializationCallback)objectLocal).OnDeserialization(null);
}
InvokeOnDeserialized(classContract);
if (!InvokeFactoryMethod(classContract))
{
// Do a conversion back from DateTimeOffsetAdapter to DateTimeOffset after deserialization.
// DateTimeOffsetAdapter is used here for deserialization purposes to bypass the ISerializable implementation
// on DateTimeOffset; which does not work in partial trust.
if (classContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
{
objectLocal = DateTimeOffsetAdapter.GetDateTimeOffset((DateTimeOffsetAdapter)objectLocal);
}
// else - do we have to call CodeInterpreter.ConvertValue()? I guess not...
}
return(objectLocal);
}
public object ReadObject(Stream stream)
{
try
{
DataContract contract = RootContract;
AddCollectionItemContractsToKnownDataContracts(contract);
_jsonDeserializer = new JavaScriptDeserializer(stream);
XmlObjectSerializerReadContextComplexJson context = new XmlObjectSerializerReadContextComplexJson(this, RootContract);
object obj = ConvertObjectToDataContract(RootContract, _jsonDeserializer.DeserializeObject(), context);
return(obj);
}
catch (Exception e)
{
if (e is TargetInvocationException || e is FormatException || e is OverflowException)
{
throw XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.GetTypeInfoError(SR.ErrorDeserializing, _rootType, e), e);
}
throw;
}
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object obj2;
string s = jsonReader.ReadElementContentAsString();
DataContractSerializer serializer = new DataContractSerializer(base.TraditionalDataContract.UnderlyingType, this.GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList), 1, false, false, null);
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(s));
XmlDictionaryReaderQuotas readerQuotas = ((JsonReaderDelegator) jsonReader).ReaderQuotas;
if (readerQuotas == null)
{
obj2 = serializer.ReadObject(stream);
}
else
{
obj2 = serializer.ReadObject(XmlDictionaryReader.CreateTextReader(stream, readerQuotas));
}
if (context != null)
{
context.AddNewObject(obj2);
}
return obj2;
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object obj;
string contentMode = jsonReader.GetAttribute(JsonGlobals.typeString);
switch (contentMode)
{
case JsonGlobals.nullString:
jsonReader.Skip();
obj = null;
break;
case JsonGlobals.booleanString:
obj = jsonReader.ReadElementContentAsBoolean();
break;
case JsonGlobals.stringString:
case null:
obj = jsonReader.ReadElementContentAsString();
break;
case JsonGlobals.numberString:
obj = ParseJsonNumber(jsonReader.ReadElementContentAsString());
break;
case JsonGlobals.objectString:
jsonReader.Skip();
obj = new object();
break;
case JsonGlobals.arrayString:
// Read as object array
return DataContractJsonSerializer.ReadJsonValue(DataContract.GetDataContract(Globals.TypeOfObjectArray), jsonReader, context);
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.JsonUnexpectedAttributeValue, contentMode)));
}
if (context != null)
{
context.AddNewObject(obj);
}
return obj;
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object obj2;
string s = jsonReader.ReadElementContentAsString();
DataContractSerializer serializer = new DataContractSerializer(base.TraditionalDataContract.UnderlyingType, this.GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList), 1, false, false, null);
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(s));
XmlDictionaryReaderQuotas readerQuotas = ((JsonReaderDelegator)jsonReader).ReaderQuotas;
if (readerQuotas == null)
{
obj2 = serializer.ReadObject(stream);
}
else
{
obj2 = serializer.ReadObject(XmlDictionaryReader.CreateTextReader(stream, readerQuotas));
}
if (context != null)
{
context.AddNewObject(obj2);
}
return(obj2);
}
public object ReadFromJson (XmlReaderDelegator xmlReader, XmlObjectSerializerReadContextComplexJson context, XmlDictionaryString emptyDictionaryString, XmlDictionaryString[] memberNames)
{
// InitArgs()
this.xmlReader = xmlReader;
this.context = context;
this.emptyDictionaryString = emptyDictionaryString;
this.memberNames = memberNames;
//DemandSerializationFormatterPermission(classContract);
//DemandMemberAccessPermission(memberAccessFlag);
CreateObject (classContract);
context.AddNewObject (objectLocal);
InvokeOnDeserializing (classContract);
string objectId = null;
if (classContract.IsISerializable)
ReadISerializable (classContract);
else
ReadClass (classContract);
if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom (classContract.UnderlyingType))
((IDeserializationCallback) objectLocal).OnDeserialization (null);
InvokeOnDeserialized(classContract);
if (!InvokeFactoryMethod (classContract)) {
// Do a conversion back from DateTimeOffsetAdapter to DateTimeOffset after deserialization.
// DateTimeOffsetAdapter is used here for deserialization purposes to bypass the ISerializable implementation
// on DateTimeOffset; which does not work in partial trust.
if (classContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
objectLocal = DateTimeOffsetAdapter.GetDateTimeOffset ((DateTimeOffsetAdapter) objectLocal);
// else - do we have to call CodeInterpreter.ConvertValue()? I guess not...
}
return objectLocal;
}
static internal void InvokeOnDeserialized(object value, DataContract contract, XmlObjectSerializerReadContextComplexJson context)
{
if (contract is ClassDataContract)
{
ClassDataContract classContract = contract as ClassDataContract;
if (classContract.BaseContract != null)
InvokeOnDeserialized(value, classContract.BaseContract, context);
if (classContract.OnDeserialized != null)
{
bool memberAccessFlag = classContract.RequiresMemberAccessForRead(null);
try
{
classContract.OnDeserialized.Invoke(value, new object[] { context.GetStreamingContext() });
}
catch (SecurityException securityException)
{
if (memberAccessFlag)
{
classContract.RequiresMemberAccessForRead(securityException);
}
else
{
throw;
}
}
catch (TargetInvocationException targetInvocationException)
{
if (targetInvocationException.InnerException == null)
throw;
//We are catching the TIE here and throws the inner exception only,
//this is needed to have a consistent exception story in all serializers
throw targetInvocationException.InnerException;
}
}
}
}
public static object ConvertDictionaryToClassDataContract(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary <string, object> deserialzedValue, XmlObjectSerializerReadContextComplexJson context)
{
if (deserialzedValue == null)
{
return(null);
}
if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
{
var tuple = deserialzedValue["DateTime"] as Tuple <DateTime, string>;
DateTimeOffset dto = new DateTimeOffset(tuple != null ? tuple.Item1 : (DateTime)deserialzedValue["DateTime"]);
return(dto.ToOffset(new TimeSpan(0, (int)deserialzedValue["OffsetMinutes"], 0)));
}
if (deserialzedValue.ContainsKey(JsonGlobals.ServerTypeString))
{
dataContract = ResolveDataContractFromTypeInformation(deserialzedValue[JsonGlobals.ServerTypeString].ToString(), dataContract, context);
}
object o = CreateInstance(dataContract);
CheckDuplicateNames(dataContract);
DataContractJsonSerializer.InvokeOnDeserializing(o, dataContract, context);
ReadClassDataContractMembers(serializer, dataContract, deserialzedValue, o, context);
DataContractJsonSerializer.InvokeOnDeserialized(o, dataContract, context);
if (dataContract.IsKeyValuePairAdapter)
{
return(dataContract.GetKeyValuePairMethodInfo.Invoke(o, Globals.EmptyTypeArray));
}
return(o);
}
public void ReflectionReadGetOnlyCollection(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContextComplexJson context, XmlDictionaryString emptyDictionaryString, XmlDictionaryString itemName, CollectionDataContract collectionContract)
{
_reflectionReader.ReflectionReadGetOnlyCollection(xmlReader, context, itemName, emptyDictionaryString /*itemNamespace*/, collectionContract);
}
private void ReadSimpleDictionary(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, CollectionDataContract collectionContract, Type keyValueType, object dictionary)
{
Type[] keyValueTypes = keyValueType.GetGenericArguments();
Type keyType = keyValueTypes[0];
Type valueType = keyValueTypes[1];
int keyTypeNullableDepth = 0;
while (keyType.IsGenericType && keyType.GetGenericTypeDefinition() == Globals.TypeOfNullable)
{
keyTypeNullableDepth++;
keyType = keyType.GetGenericArguments()[0];
}
ClassDataContract keyValueDataContract = (ClassDataContract)collectionContract.ItemContract;
DataContract keyDataContract = keyValueDataContract.Members[0].MemberTypeContract;
KeyParseMode keyParseMode = KeyParseMode.Fail;
if (keyType == Globals.TypeOfString || keyType == Globals.TypeOfObject)
{
keyParseMode = KeyParseMode.AsString;
}
else if (keyType.IsEnum)
{
keyParseMode = KeyParseMode.UsingParseEnum;
}
else if (keyDataContract.ParseMethod != null)
{
keyParseMode = KeyParseMode.UsingCustomParse;
}
if (keyParseMode == KeyParseMode.Fail)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.Format(SR.KeyTypeCannotBeParsedInSimpleDictionary,
DataContract.GetClrTypeFullName(collectionContract.UnderlyingType),
DataContract.GetClrTypeFullName(keyType))
));
}
while (true)
{
XmlNodeType nodeType = xmlReader.MoveToContent();
if (nodeType == XmlNodeType.EndElement)
{
return;
}
if (nodeType != XmlNodeType.Element)
{
throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.Element, xmlReader);
}
context.IncrementItemCount(1);
string keyString = XmlObjectSerializerReadContextComplexJson.GetJsonMemberName(xmlReader);
object pairKey;
if (keyParseMode == KeyParseMode.UsingParseEnum)
{
pairKey = Enum.Parse(keyType, keyString);
}
else if (keyParseMode == KeyParseMode.UsingCustomParse)
{
TypeCode typeCode = Type.GetTypeCode(keyDataContract.UnderlyingType);
pairKey = typeCode switch
{
TypeCode.Boolean => bool.Parse(keyString),
TypeCode.Int16 => short.Parse(keyString),
TypeCode.Int32 => int.Parse(keyString),
TypeCode.Int64 => long.Parse(keyString),
TypeCode.Char => char.Parse(keyString),
TypeCode.Byte => byte.Parse(keyString),
TypeCode.SByte => sbyte.Parse(keyString),
TypeCode.Double => double.Parse(keyString),
TypeCode.Decimal => decimal.Parse(keyString),
TypeCode.Single => float.Parse(keyString),
TypeCode.UInt16 => ushort.Parse(keyString),
TypeCode.UInt32 => uint.Parse(keyString),
TypeCode.UInt64 => ulong.Parse(keyString),
_ => keyDataContract.ParseMethod.Invoke(null, new object[] { keyString }),
};
}
else
{
pairKey = keyString;
}
if (keyTypeNullableDepth > 0)
{
throw new NotImplementedException("keyTypeNullableDepth > 0");
}
object pairValue = ReflectionReadValue(xmlReader, context, valueType, string.Empty, string.Empty);
((IDictionary)dictionary).Add(pairKey, pairValue);
}
}
public object ReadObject(Stream stream)
{
#if NET_NATIVE || MERGE_DCJS
return _serializer.ReadObject(stream);
#else
try
{
DataContract contract = RootContract;
AddCollectionItemContractsToKnownDataContracts(contract);
_jsonDeserializer = new JavaScriptDeserializer(stream);
XmlObjectSerializerReadContextComplexJson context = new XmlObjectSerializerReadContextComplexJson(this, RootContract);
object obj = ConvertObjectToDataContract(RootContract, _jsonDeserializer.DeserializeObject(), context);
return obj;
}
catch (Exception e)
{
if (e is TargetInvocationException || e is FormatException || e is OverflowException)
{
throw XmlObjectSerializer.CreateSerializationException(XmlObjectSerializer.GetTypeInfoError(SR.ErrorDeserializing, _rootType, e), e);
}
throw;
}
#endif
}
internal static object ReadJsonValue(DataContract contract, XmlReaderDelegator reader, XmlObjectSerializerReadContextComplexJson context)
{
return JsonDataContract.GetJsonDataContract(contract).ReadJsonValue(reader, context);
}
private object ConvertObjectToPrimitiveDataContract(DataContract contract, object value, XmlObjectSerializerReadContextComplexJson context)
{
// Taking the right deserialized value for datetime string based on contract information
var tuple = value as Tuple<DateTime, string>;
if (tuple != null)
{
if (contract is StringDataContract || contract.UnderlyingType == typeof(object))
{
value = tuple.Item2;
}
else
{
value = tuple.Item1;
}
}
if (contract is TimeSpanDataContract)
{
return XmlConvert.ToTimeSpan(String.Format(CultureInfo.InvariantCulture, "{0}", value));
}
else if (contract is ByteArrayDataContract)
{
return ObjectToDataContractConverter.ConvertToArray(typeof(Byte), (IList)value);
}
else if (contract is GuidDataContract)
{
return new Guid(String.Format(CultureInfo.InvariantCulture, "{0}", value));
}
else if (contract is ObjectDataContract)
{
if (value is ICollection)
{
return ConvertObjectToDataContract(DataContract.GetDataContract(Globals.TypeOfObjectArray), value, context);
}
return TryParseJsonNumber(value);
}
else if (contract is QNameDataContract)
{
return XmlObjectSerializerReadContextComplexJson.ParseQualifiedName(value.ToString());
}
else if (contract is StringDataContract)
{
if (value is bool)
{
return ((bool)value) ? Globals.True : Globals.False;
}
return value.ToString();
}
else if (contract is UriDataContract)
{
return new Uri(value.ToString(), UriKind.RelativeOrAbsolute);
}
else if (contract is DoubleDataContract)
{
if (value is float)
{
return (double)(float)value;
}
if (value is double)
{
return (double)value;
}
return double.Parse(String.Format(CultureInfo.InvariantCulture, "{0}", value), NumberStyles.Float, CultureInfo.InvariantCulture);
}
else if (contract is DecimalDataContract)
{
return decimal.Parse(String.Format(CultureInfo.InvariantCulture, "{0}", value), NumberStyles.Float, CultureInfo.InvariantCulture);
}
return Convert.ChangeType(value, contract.UnderlyingType, CultureInfo.InvariantCulture);
}
internal object ConvertObjectToDataContract(DataContract contract, object value, XmlObjectSerializerReadContextComplexJson context)
{
if (value == null)
{
return value;
}
else if (contract is PrimitiveDataContract)
{
return ConvertObjectToPrimitiveDataContract(contract, value, context);
}
else if (contract is CollectionDataContract)
{
return ObjectToDataContractConverter.ConvertICollectionToCollectionDataContract(this, (CollectionDataContract)contract, value, context);
}
else if (contract is ClassDataContract)
{
ClassDataContract classContract = contract as ClassDataContract;
if (Globals.TypeOfScriptObject_IsAssignableFrom(classContract.UnderlyingType))
{
return ConvertObjectToScriptObject(value);
}
return ObjectToDataContractConverter.ConvertDictionaryToClassDataContract(this, classContract, (Dictionary<string, object>)value, context);
}
else if (contract is EnumDataContract)
{
return Enum.ToObject(contract.UnderlyingType, ((EnumDataContract)contract).IsULong ? ulong.Parse(String.Format(CultureInfo.InvariantCulture, "{0}", value), NumberStyles.Float, NumberFormatInfo.InvariantInfo) : value);
}
else if (contract is XmlDataContract)
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(contract.UnderlyingType, GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList));
MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes((string)value));
return dataContractSerializer.ReadObject(XmlDictionaryReader.CreateTextReader(memoryStream, XmlDictionaryReaderQuotas.Max));
}
return value;
}
private static ClassDataContract ResolveDataContractFromTypeInformation(string typeName, DataContract contract, XmlObjectSerializerReadContextComplexJson context)
{
DataContract dataContract = context.ResolveDataContractFromType(typeName, Globals.DataContractXsdBaseNamespace, contract);
if (dataContract == null)
{
XmlQualifiedName qname = XmlObjectSerializerReadContextComplexJson.ParseQualifiedName(typeName);
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.DcTypeNotFoundOnDeserialize, qname.Namespace, qname.Name)));
}
return (ClassDataContract)dataContract;
}
private static object ConvertDictionary(DataContractJsonSerializer serializer, DataContract contract, object obj, XmlObjectSerializerReadContextComplexJson context)
{
System.Diagnostics.Debug.Assert(obj is IDictionary, "obj is IDictionary");
Dictionary<string, object> dictOfStringObject = obj as Dictionary<string, object>;
object serverTypeStringValue;
if (dictOfStringObject.TryGetValue(JsonGlobals.ServerTypeString, out serverTypeStringValue))
{
return ConvertDictionaryToClassDataContract(serializer,
ResolveDataContractFromTypeInformation(serverTypeStringValue.ToString(), null, context),
dictOfStringObject, context);
}
else if (dictOfStringObject.ContainsKey("DateTime") && dictOfStringObject.ContainsKey("OffsetMinutes"))
{
return ConvertDictionaryToClassDataContract(serializer, (ClassDataContract)DataContract.GetDataContract(typeof(DateTimeOffset)), dictOfStringObject, context);
}
else
{
//Its either an empty object "{}" or a weakly typed Json Object such as {"a",1;"b";2} which we dont support reading in Orcas
return new Object();
}
}
internal static object ReadJsonValue(DataContract contract, XmlReaderDelegator reader, XmlObjectSerializerReadContextComplexJson context)
{
return(JsonDataContract.GetJsonDataContract(contract).ReadJsonValue(reader, context));
}
public virtual object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
return TraditionalDataContract.ReadXmlValue(jsonReader, context);
}
public object ReflectionReadClass(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContextComplexJson context, XmlDictionaryString emptyDictionaryString, XmlDictionaryString[] memberNames)
{
Debug.Assert(_classContract != null);
return(_reflectionReader.ReflectionReadClass(xmlReader, context, memberNames, null /*memberNamespaces*/, _classContract));
}
//Deserialize '[...]' json string. The contents of the list can also be a dictionary i.e. [{...}]. The content type is detected
//based on the type of CollectionDataContract.ItemContract.
public static object ConvertICollectionToCollectionDataContract(DataContractJsonSerializer serializer, CollectionDataContract contract, object deserializedValue, XmlObjectSerializerReadContextComplexJson context)
{
Dictionary<string, object> valueAsDictionary = deserializedValue as Dictionary<string, object>;
//Check to see if the dictionary (if it is a dictionary)is a regular Dictionary i.e { Key="key"; Value="value} and doesnt contain the __type string
//for ex. the dictionary { __type="XXX"; Key="key"; Value="value} needs to be parsed as ClassDataContract
if (valueAsDictionary != null && (!valueAsDictionary.ContainsKey(JsonGlobals.KeyString) || valueAsDictionary.ContainsKey(JsonGlobals.ServerTypeString)))
{
//If not then its a dictionary for either of these cases
//1. Empty object - {}
//2. Containes the __type information
//3. Is a DateTimeOffsetDictionary
return ConvertDictionary(serializer, contract, valueAsDictionary, context);
}
object returnValue = (contract.Constructor != null) ? contract.Constructor.Invoke(Array.Empty<Type>()) : null;
bool isCollectionDataContractDictionary = contract.IsDictionary;
MethodInfo addMethod = contract.AddMethod;
bool convertToArray = contract.Kind == CollectionKind.Array;
if (contract.UnderlyingType.GetTypeInfo().IsInterface || returnValue == null)
{
switch (contract.Kind)
{
case CollectionKind.Collection:
case CollectionKind.GenericCollection:
case CollectionKind.Enumerable:
case CollectionKind.GenericEnumerable:
case CollectionKind.List:
case CollectionKind.GenericList:
case CollectionKind.Array:
if (contract.UnderlyingType.GetTypeInfo().IsValueType)
{
//Initialize struct
returnValue = XmlFormatReaderGenerator.TryGetUninitializedObjectWithFormatterServices(contract.UnderlyingType);
}
else
{
returnValue = Activator.CreateInstance(Globals.TypeOfListGeneric.MakeGenericType(contract.ItemType));
convertToArray = true;
}
break;
case CollectionKind.GenericDictionary:
returnValue = Activator.CreateInstance(Globals.TypeOfDictionaryGeneric.MakeGenericType(contract.ItemType.GetGenericArguments()));
break;
case CollectionKind.Dictionary:
returnValue = Activator.CreateInstance(Globals.TypeOfDictionaryGeneric.MakeGenericType(Globals.TypeOfObject, Globals.TypeOfObject));
break;
}
}
if (addMethod == null)
{
//addMethod is null for IDictionary, IList and array types.
Type[] paramArray = (contract.ItemType.GetTypeInfo().IsGenericType && !convertToArray) ? contract.ItemType.GetGenericArguments() : new Type[] { contract.ItemType };
addMethod = returnValue.GetType().GetMethod(Globals.AddMethodName, paramArray);
}
IEnumerator enumerator = ((ICollection)deserializedValue).GetEnumerator();
object currentItem = null;
object[] currentItemArray = null;
while (enumerator.MoveNext())
{
DataContract itemContract = contract.ItemContract;
if (itemContract is ClassDataContract)
{
itemContract = XmlObjectSerializerWriteContextComplexJson.GetRevisedItemContract(itemContract);
}
currentItem = serializer.ConvertObjectToDataContract(itemContract, enumerator.Current, context);
currentItemArray = new object[] { currentItem };
if (isCollectionDataContractDictionary)
{
Type currentItemType = currentItem.GetType();
MemberInfo keyMember = currentItemType.GetMember("Key")[0];
MemberInfo valueMember = currentItemType.GetMember("Value")[0];
currentItemArray = new object[] { DataContractToObjectConverter.GetMemberValue(currentItem, keyMember, currentItemType), DataContractToObjectConverter.GetMemberValue(currentItem, valueMember, currentItemType) };
}
addMethod.Invoke(returnValue, currentItemArray);
}
return (convertToArray) ? ConvertToArray(contract.ItemType, (ICollection)returnValue) : returnValue;
}
public object ReadCollectionFromJson (XmlReaderDelegator xmlReader, XmlObjectSerializerReadContextComplexJson context, XmlDictionaryString emptyDictionaryString, XmlDictionaryString itemName, CollectionDataContract collectionContract)
{
#region GenerateCollectionReaderHelper
// InitArgs()
this.xmlReader = xmlReader;
this.context = context;
this.emptyDictionaryString = emptyDictionaryString;
this.itemName = itemName;
this.collectionContract = collectionContract;
#endregion
ReadCollection (collectionContract);
return objectLocal;
}
private static void ReadClassDataContractMembers(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary <string, object> deserialzedValue, object newInstance, XmlObjectSerializerReadContextComplexJson context)
{
if (dataContract.BaseContract != null)
{
ReadClassDataContractMembers(serializer, dataContract.BaseContract, deserialzedValue, newInstance, context);
}
for (int i = 0; i < dataContract.Members.Count; i++)
{
DataMember member = dataContract.Members[i];
object currentMemberValue;
if (deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name), out currentMemberValue) ||
dataContract.IsKeyValuePairAdapter && deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name.ToLowerInvariant()), out currentMemberValue))
{
if (member.MemberType.GetTypeInfo().IsPrimitive || currentMemberValue == null)
{
SetMemberValue(newInstance, serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context), dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
}
else
{
context.PushKnownTypes(dataContract);
object subMemberValue = serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context);
Type declaredType = (member.MemberType.GetTypeInfo().IsGenericType&& member.MemberType.GetGenericTypeDefinition() == Globals.TypeOfNullable)
? Nullable.GetUnderlyingType(member.MemberType)
: member.MemberType;
if (!(declaredType == Globals.TypeOfObject && subMemberValue.GetType() == Globals.TypeOfObjectArray) && declaredType != subMemberValue.GetType())
{
DataContract memberValueContract = DataContract.GetDataContract(subMemberValue.GetType());
context.CheckIfTypeNeedsVerifcation(member.MemberTypeContract, memberValueContract);
}
if (member.IsGetOnlyCollection)
{
PopulateReadOnlyCollection(newInstance, member, (IEnumerable)subMemberValue);
}
else
{
SetMemberValue(newInstance, subMemberValue, dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
}
context.PopKnownTypes(dataContract);
}
}
else if (member.IsRequired)
{
XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(dataContract.MemberNames[i].Value, dataContract.UnderlyingType);
}
}
}
static internal void InvokeOnDeserialized(object value, DataContract contract, XmlObjectSerializerReadContextComplexJson context)
{
if (contract is ClassDataContract)
{
ClassDataContract classContract = contract as ClassDataContract;
if (classContract.BaseContract != null)
{
InvokeOnDeserialized(value, classContract.BaseContract, context);
}
if (classContract.OnDeserialized != null)
{
bool memberAccessFlag = classContract.RequiresMemberAccessForRead(null, JsonGlobals.JsonSerializationPatterns);
try
{
DisallowMemberAccess(memberAccessFlag);
classContract.OnDeserialized.Invoke(value, new object[] { context.GetStreamingContext() });
}
catch (SecurityException securityException)
{
if (memberAccessFlag)
{
classContract.RequiresMemberAccessForRead(securityException, JsonGlobals.JsonSerializationPatterns);
}
else
{
throw;
}
}
catch (TargetInvocationException targetInvocationException)
{
if (targetInvocationException.InnerException == null)
{
throw;
}
//We are catching the TIE here and throws the inner exception only,
//this is needed to have a consistent exception story in all serializers
throw targetInvocationException.InnerException;
}
}
}
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
jsonReader.Read();
object o = null;
if (context.IsGetOnlyCollection)
{
// IsGetOnlyCollection value has already been used to create current collectiondatacontract, value can now be reset.
context.IsGetOnlyCollection = false;
JsonFormatGetOnlyReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, JsonGlobals.itemDictionaryString, TraditionalCollectionDataContract);
}
else
{
o = JsonFormatReaderDelegate(jsonReader, context, XmlDictionaryString.Empty, JsonGlobals.itemDictionaryString, TraditionalCollectionDataContract);
}
jsonReader.ReadEndElement();
return o;
}
private object ConvertObjectToPrimitiveDataContract(DataContract contract, object value, XmlObjectSerializerReadContextComplexJson context)
{
// Taking the right deserialized value for datetime string based on contract information
var tuple = value as Tuple <DateTime, string>;
if (tuple != null)
{
if (contract is StringDataContract || contract.UnderlyingType == typeof(object))
{
value = tuple.Item2;
}
else
{
value = tuple.Item1;
}
}
if (contract is TimeSpanDataContract)
{
return(XmlConvert.ToTimeSpan(String.Format(CultureInfo.InvariantCulture, "{0}", value)));
}
else if (contract is ByteArrayDataContract)
{
return(ObjectToDataContractConverter.ConvertToArray(typeof(Byte), (IList)value));
}
else if (contract is GuidDataContract)
{
return(new Guid(String.Format(CultureInfo.InvariantCulture, "{0}", value)));
}
else if (contract is ObjectDataContract)
{
if (value is ICollection)
{
return(ConvertObjectToDataContract(DataContract.GetDataContract(Globals.TypeOfObjectArray), value, context));
}
return(TryParseJsonNumber(value));
}
else if (contract is QNameDataContract)
{
return(XmlObjectSerializerReadContextComplexJson.ParseQualifiedName(value.ToString()));
}
else if (contract is StringDataContract)
{
if (value is bool)
{
return(((bool)value) ? Globals.True : Globals.False);
}
return(value.ToString());
}
else if (contract is UriDataContract)
{
return(new Uri(value.ToString(), UriKind.RelativeOrAbsolute));
}
else if (contract is DoubleDataContract)
{
if (value is float)
{
return((double)(float)value);
}
if (value is double)
{
return((double)value);
}
return(double.Parse(String.Format(CultureInfo.InvariantCulture, "{0}", value), NumberStyles.Float, CultureInfo.InvariantCulture));
}
else if (contract is DecimalDataContract)
{
return(decimal.Parse(String.Format(CultureInfo.InvariantCulture, "{0}", value), NumberStyles.Float, CultureInfo.InvariantCulture));
}
return(Convert.ChangeType(value, contract.UnderlyingType, CultureInfo.InvariantCulture));
}
internal object ConvertObjectToDataContract(DataContract contract, object value, XmlObjectSerializerReadContextComplexJson context)
{
if (value == null)
{
return(value);
}
else if (contract is PrimitiveDataContract)
{
return(ConvertObjectToPrimitiveDataContract(contract, value, context));
}
else if (contract is CollectionDataContract)
{
return(ObjectToDataContractConverter.ConvertICollectionToCollectionDataContract(this, (CollectionDataContract)contract, value, context));
}
else if (contract is ClassDataContract)
{
ClassDataContract classContract = contract as ClassDataContract;
if (Globals.TypeOfScriptObject_IsAssignableFrom(classContract.UnderlyingType))
{
return(ConvertObjectToScriptObject(value));
}
return(ObjectToDataContractConverter.ConvertDictionaryToClassDataContract(this, classContract, (Dictionary <string, object>)value, context));
}
else if (contract is EnumDataContract)
{
return(Enum.ToObject(contract.UnderlyingType, ((EnumDataContract)contract).IsULong ? ulong.Parse(String.Format(CultureInfo.InvariantCulture, "{0}", value), NumberStyles.Float, NumberFormatInfo.InvariantInfo) : value));
}
else if (contract is XmlDataContract)
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(contract.UnderlyingType, GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList));
MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes((string)value));
return(dataContractSerializer.ReadObject(XmlDictionaryReader.CreateTextReader(memoryStream, XmlDictionaryReaderQuotas.Max)));
}
return(value);
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
string xmlContent = jsonReader.ReadElementContentAsString();
DataContractSerializer dataContractSerializer = new DataContractSerializer(TraditionalDataContract.UnderlyingType,
GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList), 1, false, false); // maxItemsInObjectGraph // ignoreExtensionDataObject // preserveObjectReferences
MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlContent));
object xmlValue;
XmlDictionaryReaderQuotas quotas = ((JsonReaderDelegator)jsonReader).ReaderQuotas;
if (quotas == null)
{
xmlValue = dataContractSerializer.ReadObject(memoryStream);
}
else
{
xmlValue = dataContractSerializer.ReadObject(XmlDictionaryReader.CreateTextReader(memoryStream, quotas));
}
if (context != null)
{
context.AddNewObject(xmlValue);
}
return xmlValue;
}
