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; } } } }
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; }