private void CreateObject(ClassDataContract classContract) { Type typeOfValueType = this.objectType = classContract.UnderlyingType; if (typeOfValueType.IsValueType && !classContract.IsNonAttributedType) { typeOfValueType = Globals.TypeOfValueType; } this.objectLocal = this.ilg.DeclareLocal(typeOfValueType, "objectDeserialized"); if (classContract.UnderlyingType == Globals.TypeOfDBNull) { this.ilg.LoadMember(Globals.TypeOfDBNull.GetField("Value")); this.ilg.Stloc(this.objectLocal); } else if (classContract.IsNonAttributedType) { if (typeOfValueType.IsValueType) { this.ilg.Ldloca(this.objectLocal); this.ilg.InitObj(typeOfValueType); } else { this.ilg.New(classContract.GetNonAttributedTypeConstructor()); this.ilg.Stloc(this.objectLocal); } } else { this.ilg.Call(null, XmlFormatGeneratorStatics.GetUninitializedObjectMethod, DataContract.GetIdForInitialization(classContract)); this.ilg.ConvertValue(Globals.TypeOfObject, typeOfValueType); this.ilg.Stloc(this.objectLocal); } }
private void AddClassDataContract(ClassDataContract classDataContract) { if (classDataContract.BaseContract != null) { this.Add(classDataContract.BaseContract.StableName, classDataContract.BaseContract); } if (!classDataContract.IsISerializable && (classDataContract.Members != null)) { for (int i = 0; i < classDataContract.Members.Count; i++) { DataMember dataMember = classDataContract.Members[i]; DataContract memberTypeDataContract = this.GetMemberTypeDataContract(dataMember); if ((this.dataContractSurrogate != null) && (dataMember.MemberInfo != null)) { object obj2 = DataContractSurrogateCaller.GetCustomDataToExport(this.dataContractSurrogate, dataMember.MemberInfo, memberTypeDataContract.UnderlyingType); if (obj2 != null) { this.SurrogateDataTable.Add(dataMember, obj2); } } this.Add(memberTypeDataContract.StableName, memberTypeDataContract); } } this.AddKnownDataContracts(classDataContract.KnownDataContracts); }
internal int ReflectionWriteMembers(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, ClassDataContract derivedMostClassContract) { int memberCount = (classContract.BaseContract == null) ? 0 : ReflectionWriteMembers(xmlWriter, obj, context, classContract.BaseContract, derivedMostClassContract); Type classType = classContract.UnadaptedClassType; XmlDictionaryString[] memberNames = classContract.MemberNames; XmlDictionaryString ns = classContract.Namespace; context.IncrementItemCount(classContract.Members.Count); for (int i = 0; i < classContract.Members.Count; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; if (member.IsGetOnlyCollection) { context.StoreIsGetOnlyCollection(); } bool writeXsiType = CheckIfMemberHasConflict(member, classContract, derivedMostClassContract); MemberInfo memberInfo = member.MemberInfo; object memberValue = ReflectionGetMemberValue(obj, memberInfo); if (writeXsiType || !ReflectionTryWritePrimitive(xmlWriter, context, memberType, memberValue, member.MemberInfo, null /*arrayItemIndex*/, ns, memberNames[i] /*nameLocal*/, i + _childElementIndex)) { ReflectionWriteStartElement(memberType, ns, ns.Value, member.Name, 0); if (classContract.ChildElementNamespaces[i + _childElementIndex] != null) { var nsChildElement = classContract.ChildElementNamespaces[i + _childElementIndex]; _arg0XmlWriter.WriteNamespaceDecl(nsChildElement); } ReflectionWriteValue(memberType, memberValue, writeXsiType); ReflectionWriteEndElement(); } } return 0; }
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; }
private void DemandSerializationFormatterPermission(ClassDataContract classContract) { if (!classContract.HasDataContract && !classContract.IsNonAttributedType) { this.ilg.Call(this.contextArg, XmlFormatGeneratorStatics.DemandSerializationFormatterPermissionMethod); } }
internal XmlFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract) { if (_useReflection) { return new ReflectionXmlFormatWriter().ReflectionWriteClass; } else { _ilg = new CodeGenerator(); bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null); try { _ilg.BeginMethod("Write" + classContract.StableName.Name + "ToXml", Globals.TypeOfXmlFormatClassWriterDelegate, memberAccessFlag); } catch (SecurityException securityException) { if (memberAccessFlag) { classContract.RequiresMemberAccessForWrite(securityException); } else { throw; } } InitArgs(classContract.UnderlyingType); WriteClass(classContract); return (XmlFormatClassWriterDelegate)_ilg.EndMethod(); } }
public JsonFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract) { _ilg = new CodeGenerator(); bool memberAccessFlag = classContract.RequiresMemberAccessForRead(null); try { BeginMethod(_ilg, "Read" + DataContract.SanitizeTypeName(classContract.StableName.Name) + "FromJson", typeof(JsonFormatClassReaderDelegate), memberAccessFlag); } catch (SecurityException securityException) { if (memberAccessFlag) { classContract.RequiresMemberAccessForRead(securityException); } else { throw; } } InitArgs(); CreateObject(classContract); _ilg.Call(_contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, _objectLocal); InvokeOnDeserializing(classContract); if (classContract.IsISerializable) ReadISerializable(classContract); else ReadClass(classContract); if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom(classContract.UnderlyingType)) { _ilg.Call(_objectLocal, JsonFormatGeneratorStatics.OnDeserializationMethod, null); } InvokeOnDeserialized(classContract); if (!InvokeFactoryMethod(classContract)) { _ilg.Load(_objectLocal); // 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) { _ilg.ConvertValue(_objectLocal.LocalType, Globals.TypeOfDateTimeOffsetAdapter); _ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetMethod); _ilg.ConvertValue(Globals.TypeOfDateTimeOffset, _ilg.CurrentMethod.ReturnType); } //Copy the KeyValuePairAdapter<K,T> to a KeyValuePair<K,T>. else if (classContract.IsKeyValuePairAdapter) { _ilg.Call(classContract.GetKeyValuePairMethodInfo); _ilg.ConvertValue(Globals.TypeOfKeyValuePair.MakeGenericType(classContract.KeyValuePairGenericArguments), _ilg.CurrentMethod.ReturnType); } else { _ilg.ConvertValue(_objectLocal.LocalType, _ilg.CurrentMethod.ReturnType); } } return (JsonFormatClassReaderDelegate)_ilg.EndMethod(); }
public void ReflectionWriteClass(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, XmlDictionaryString[] memberNames) { InvokeOnSerializing(obj, context, classContract); obj = ResolveAdapterType(obj, classContract); ReflectionWriteMembers(xmlWriter, obj, context, classContract, classContract, 0 /*childElementIndex*/, memberNames); InvokeOnSerialized(obj, context, classContract); }
static DataContract ProcessClassDataContract(ClassDataContract contract, ExportContext context, MemberInfo memberNode) { string prefix = context.SetNamespace(contract.Namespace.Value); foreach (DataMember member in GetDataMembers(contract)) { if (member.MemberInfo.Name == memberNode.Name && member.MemberInfo.DeclaringType.IsAssignableFrom(memberNode.DeclaringType)) { context.WriteChildToContext(member, prefix); return member.MemberTypeContract; } } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.QueryGeneratorPathToMemberNotFound))); }
private static void CheckDuplicateNames(ClassDataContract dataContract) { if (dataContract.MemberNames != null) { Dictionary<string, object> memberTable = new Dictionary<string, object>(); for (int i = 0; i < dataContract.MemberNames.Length; i++) { if (memberTable.ContainsKey(dataContract.MemberNames[i].Value)) { throw new SerializationException(SR.Format(SR.JsonDuplicateMemberInInput, dataContract.MemberNames[i].Value)); } memberTable.Add(dataContract.MemberNames[i].Value, null); } } }
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); } } }
private void ReflectionInitArgs(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract) { if (obj.GetType() == typeof(DateTimeOffset)) { obj = DateTimeOffsetAdapter.GetDateTimeOffsetAdapter((DateTimeOffset)obj); } else if (obj.GetType().GetTypeInfo().IsGenericType && obj.GetType().GetGenericTypeDefinition() == typeof(KeyValuePair<,>)) { obj = classContract.KeyValuePairAdapterConstructorInfo.Invoke(new object[] { obj }); } _arg0XmlWriter = xmlWriter; _arg1Object = obj; _arg2Context = context; _arg3ClassDataContract = classContract; }
private static DataContract ProcessClassDataContract(ClassDataContract contract, ExportContext context, MemberInfo memberNode) { string prefix = context.SetNamespace(contract.Namespace.Value); if (contract.Members != null) { foreach (DataMember member in contract.Members) { if (member.MemberInfo == memberNode) { context.WriteChildToContext(member, prefix); return member.MemberTypeContract; } } } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("QueryGeneratorPathToMemberNotFound"))); }
static IEnumerable<DataMember> GetDataMembers(ClassDataContract contract) { if (contract.BaseContract != null) { foreach (DataMember baseClassMember in GetDataMembers(contract.BaseContract)) { yield return baseClassMember; } } if (contract.Members != null) { foreach (DataMember member in contract.Members) { yield return member; } } }
public XmlFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract) { try { if (TD.DCGenReaderStartIsEnabled()) { TD.DCGenReaderStart("Class", classContract.UnderlyingType.FullName); } return helper.GenerateClassReader(classContract); } finally { if (TD.DCGenReaderStopIsEnabled()) { TD.DCGenReaderStop(); } } }
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract) { try { if (TD.DCJsonGenWriterStartIsEnabled()) { TD.DCJsonGenWriterStart("Class", classContract.UnderlyingType.FullName); } return helper.GenerateClassWriter(classContract); } finally { if (TD.DCJsonGenWriterStopIsEnabled()) { TD.DCJsonGenWriterStop(); } } }
public void WriteToXml (XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract dataContract) { this.writer = xmlWriter; this.obj = obj; this.ctx = context; this.dataContract = dataContract; InitArgs (classContract.UnderlyingType); // DemandSerializationFormatterPermission (classContract) - irrelevant // DemandMemberAccessPermission (memberAccessFlag) - irrelevant if (classContract.IsReadOnlyContract) { DataContract.ThrowInvalidDataContractException (classContract.SerializationExceptionMessage, null); } WriteClass (classContract); }
internal XmlFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract) { if (DataContractSerializer.Option == SerializationOption.ReflectionOnly) { return new ReflectionXmlFormatWriter().ReflectionWriteClass; } #if NET_NATIVE else if (DataContractSerializer.Option == SerializationOption.ReflectionAsBackup) { return new ReflectionXmlFormatWriter().ReflectionWriteClass; } #endif else { #if USE_REFEMIT || NET_NATIVE throw new InvalidOperationException("Cannot generate class writer"); #else _ilg = new CodeGenerator(); bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null); try { _ilg.BeginMethod("Write" + classContract.StableName.Name + "ToXml", Globals.TypeOfXmlFormatClassWriterDelegate, memberAccessFlag); } catch (SecurityException securityException) { if (memberAccessFlag) { classContract.RequiresMemberAccessForWrite(securityException); } else { throw; } } InitArgs(classContract.UnderlyingType); WriteClass(classContract); return (XmlFormatClassWriterDelegate)_ilg.EndMethod(); #endif } }
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract) { this.ilg = new CodeGenerator(); bool allowPrivateMemberAccess = classContract.RequiresMemberAccessForWrite(null); try { this.BeginMethod(this.ilg, "Write" + classContract.StableName.Name + "ToJson", typeof(JsonFormatClassWriterDelegate), allowPrivateMemberAccess); } catch (SecurityException exception) { if (!allowPrivateMemberAccess || !exception.PermissionType.Equals(typeof(ReflectionPermission))) { throw; } classContract.RequiresMemberAccessForWrite(exception); } this.InitArgs(classContract.UnderlyingType); this.memberNamesArg = this.ilg.GetArg(4); this.DemandSerializationFormatterPermission(classContract); this.DemandMemberAccessPermission(allowPrivateMemberAccess); this.WriteClass(classContract); return (JsonFormatClassWriterDelegate) this.ilg.EndMethod(); }
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract) { _ilg = new CodeGenerator(); bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null, JsonGlobals.JsonSerializationPatterns); try { BeginMethod(_ilg, "Write" + DataContract.SanitizeTypeName(classContract.StableName.Name) + "ToJson", typeof(JsonFormatClassWriterDelegate), memberAccessFlag); } catch (SecurityException securityException) { if (memberAccessFlag) { classContract.RequiresMemberAccessForWrite(securityException, JsonGlobals.JsonSerializationPatterns); } else { throw; } } InitArgs(classContract.UnderlyingType); _memberNamesArg = _ilg.GetArg(4); WriteClass(classContract); return (JsonFormatClassWriterDelegate)_ilg.EndMethod(); }
protected override void ReflectionReadMembers(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces, ClassDataContract classContract, ref object obj) { int memberCount = classContract.MemberNames.Length; context.IncrementItemCount(memberCount); int memberIndex = -1; int firstRequiredMember; bool[] requiredMembers = GetRequiredMembers(classContract, out firstRequiredMember); bool hasRequiredMembers = (firstRequiredMember < memberCount); int requiredIndex = hasRequiredMembers ? firstRequiredMember : -1; DataMember[] members = new DataMember[memberCount]; int reflectedMemberCount = ReflectionGetMembers(classContract, members); Debug.Assert(reflectedMemberCount == memberCount, "The value returned by ReflectionGetMembers() should equal to memberCount."); while (true) { if (!XmlObjectSerializerReadContext.MoveToNextElement(xmlReader)) { return; } if (hasRequiredMembers) { memberIndex = context.GetMemberIndexWithRequiredMembers(xmlReader, memberNames, memberNamespaces, memberIndex, requiredIndex, null); } else { memberIndex = context.GetMemberIndex(xmlReader, memberNames, memberNamespaces, memberIndex, null); } // GetMemberIndex returns memberNames.Length if member not found if (memberIndex < members.Length) { ReflectionReadMember(xmlReader, context, classContract, ref obj, memberIndex, members); requiredIndex = memberIndex + 1; } } }
private bool CheckIfMemberHasConflict(DataMember member, ClassDataContract classContract, ClassDataContract derivedMostClassContract) { if (this.CheckIfConflictingMembersHaveDifferentTypes(member)) { return true; } string name = member.Name; string str2 = classContract.StableName.Namespace; for (ClassDataContract contract = derivedMostClassContract; (contract != null) && (contract != classContract); contract = contract.BaseContract) { if (str2 == contract.StableName.Namespace) { List<DataMember> members = contract.Members; for (int i = 0; i < members.Count; i++) { if (name == members[i].Name) { return this.CheckIfConflictingMembersHaveDifferentTypes(members[i]); } } } } return false; }
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract) { return _helper.GenerateClassWriter(classContract); }
public JsonClassDataContract(ClassDataContract traditionalDataContract) : base(new JsonClassDataContractCriticalHelper(traditionalDataContract)) { _helper = base.Helper as JsonClassDataContractCriticalHelper; }
public void ReflectionWriteClass(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract) { _reflectionClassWriter.ReflectionWriteClass(xmlWriter, obj, context, classContract, null /*memberNames*/); }
private static void WriteClassDataContractMembers(DataContractJsonSerializer serializer, ClassDataContract dataContract, ref Dictionary <string, object> classToDictionary, object value, XmlObjectSerializerWriteContextComplexJson context) { if (dataContract.BaseContract != null) { WriteClassDataContractMembers(serializer, dataContract.BaseContract, ref classToDictionary, value, context); } for (int i = 0; i < dataContract.Members.Count; i++) { DataMember member = dataContract.Members[i]; object memberValue = GetMemberValue(value, dataContract.Members[i].MemberInfo, dataContract.UnderlyingType); string memberName = System.Xml.XmlConvert.DecodeName(member.Name); if (classToDictionary.ContainsKey(memberName)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.Format(SR.JsonDuplicateMemberNames, DataContract.GetClrTypeFullName(dataContract.UnderlyingType), memberName))); } if (!member.EmitDefaultValue) { //Dont emit value if its null or default(valuetype) if (memberValue == null || (member.MemberTypeContract.IsValueType && object.Equals(memberValue, Activator.CreateInstance(member.MemberType)))) { continue; } } if (memberValue == null || IsTypePrimitive(member.MemberType)) { classToDictionary[memberName] = memberValue; } else { Type memberValueType = memberValue.GetType(); if (member.MemberType == memberValueType || //Special case Nullable<DateTimeOffset> and Nullable<Struct> (member.IsNullable && !EmitTypeInformation(member.MemberTypeContract, memberValueType))) { classToDictionary[memberName] = serializer.ConvertDataContractToObject(memberValue, member.MemberTypeContract, context, false, member.MemberTypeContract.UnderlyingType.TypeHandle); } else { //Push KnownTypes of this DataContract context.PushKnownTypes(dataContract); DataContract memberValueContract = DataContract.GetDataContract(memberValue.GetType()); if (member.MemberType.GetTypeInfo().IsInterface) { XmlObjectSerializerWriteContextComplexJson.VerifyObjectCompatibilityWithInterface(memberValueContract, memberValue, member.MemberType); } context.CheckIfTypeNeedsVerifcation(member.MemberTypeContract, memberValueContract); classToDictionary[memberName] = serializer.ConvertDataContractToObject(memberValue, memberValueContract, context, true, member.MemberTypeContract.UnderlyingType.TypeHandle); context.PopKnownTypes(dataContract); } } } }
private void ExportCollectionDataContract(CollectionDataContract collectionDataContract, XmlSchema schema) { XmlSchemaComplexType type = new XmlSchemaComplexType(); type.Name = collectionDataContract.StableName.Name; schema.Items.Add(type); XmlElement?genericInfoElement = null, isDictionaryElement = null; if (collectionDataContract.UnderlyingType.IsGenericType && CollectionDataContract.IsCollectionDataContract(collectionDataContract.UnderlyingType)) { genericInfoElement = ExportGenericInfo(collectionDataContract.UnderlyingType, Globals.GenericTypeLocalName, Globals.SerializationNamespace); } if (collectionDataContract.IsDictionary) { isDictionaryElement = ExportIsDictionary(); } type.Annotation = GetSchemaAnnotation(isDictionaryElement, genericInfoElement, ExportSurrogateData(collectionDataContract)); XmlSchemaSequence rootSequence = new XmlSchemaSequence(); XmlSchemaElement element = new XmlSchemaElement(); element.Name = collectionDataContract.ItemName; element.MinOccurs = 0; element.MaxOccursString = Globals.OccursUnbounded; if (collectionDataContract.IsDictionary) { ClassDataContract keyValueContract = (collectionDataContract.ItemContract as ClassDataContract) !; XmlSchemaComplexType keyValueType = new XmlSchemaComplexType(); XmlSchemaSequence keyValueSequence = new XmlSchemaSequence(); foreach (DataMember dataMember in keyValueContract.Members !) { XmlSchemaElement keyValueElement = new XmlSchemaElement(); keyValueElement.Name = dataMember.Name; SetElementType(keyValueElement, DataContractSet.GetMemberTypeDataContract(dataMember), schema); SchemaHelper.AddElementForm(keyValueElement, schema); if (dataMember.IsNullable) { keyValueElement.IsNillable = true; } keyValueElement.Annotation = GetSchemaAnnotation(ExportSurrogateData(dataMember)); keyValueSequence.Items.Add(keyValueElement); } keyValueType.Particle = keyValueSequence; element.SchemaType = keyValueType; } else { if (collectionDataContract.IsItemTypeNullable) { element.IsNillable = true; } DataContract itemContract = DataContractSet.GetItemTypeDataContract(collectionDataContract); SetElementType(element, itemContract, schema); } SchemaHelper.AddElementForm(element, schema); rootSequence.Items.Add(element); type.Particle = rootSequence; if (collectionDataContract.IsReference) { AddReferenceAttributes(type.Attributes, schema); } }
public object ReflectionReadClass(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext?context, XmlDictionaryString[]?memberNames, XmlDictionaryString[]?memberNamespaces, ClassDataContract classContract) { Debug.Assert(context != null); object obj = CreateObject(classContract); context.AddNewObject(obj); InvokeOnDeserializing(context, classContract, obj); if (classContract.IsISerializable) { obj = ReadISerializable(xmlReader, context, classContract); } else { Debug.Assert(memberNames != null); ReflectionReadMembers(xmlReader, context, memberNames, memberNamespaces, classContract, ref obj); } if (obj is IObjectReference objectReference) { obj = context.GetRealObject(objectReference, context.GetObjectId()); } obj = ResolveAdapterObject(obj, classContract); InvokeDeserializationCallback(obj); InvokeOnDeserialized(context, classContract, obj); return(obj); }
public ReflectionXmlClassReader(ClassDataContract classDataContract) { Debug.Assert(classDataContract != null); _classContract = classDataContract; _reflectionReader = new ReflectionXmlReader(); }
void WriteClass(ClassDataContract classContract) { InvokeOnSerializing(classContract); if (classContract.IsISerializable) { ilg.Call(contextArg, JsonFormatGeneratorStatics.WriteJsonISerializableMethod, xmlWriterArg, objectLocal); } else { if (classContract.HasExtensionData) { LocalBuilder extensionDataLocal = ilg.DeclareLocal(Globals.TypeOfExtensionDataObject, "extensionData"); ilg.Load(objectLocal); ilg.ConvertValue(objectLocal.LocalType, Globals.TypeOfIExtensibleDataObject); ilg.LoadMember(JsonFormatGeneratorStatics.ExtensionDataProperty); ilg.Store(extensionDataLocal); ilg.Call(contextArg, XmlFormatGeneratorStatics.WriteExtensionDataMethod, xmlWriterArg, extensionDataLocal, -1); WriteMembers(classContract, extensionDataLocal, classContract); } else WriteMembers(classContract, null, classContract); } InvokeOnSerialized(classContract); }
void ThrowIfCannotSerializeReadOnlyTypes(ClassDataContract classContract) { ThrowIfCannotSerializeReadOnlyTypes(XmlFormatGeneratorStatics.ClassSerializationExceptionMessageProperty); }
private XmlFormatClassReaderDelegate CreateReflectionXmlClassReader(ClassDataContract classContract) { return(new ReflectionXmlClassReader(classContract).ReflectionReadClass); }
private bool CheckIfMemberHasConflict(DataMember member, ClassDataContract classContract, ClassDataContract derivedMostClassContract) { // Check for conflict with base type members if (CheckIfConflictingMembersHaveDifferentTypes(member)) { return(true); } // Check for conflict with derived type members string name = member.Name; string ns = classContract.StableName.Namespace; ClassDataContract currentContract = derivedMostClassContract; while (currentContract != null && currentContract != classContract) { if (ns == currentContract.StableName.Namespace) { List <DataMember> members = currentContract.Members; for (int j = 0; j < members.Count; j++) { if (name == members[j].Name) { return(CheckIfConflictingMembersHaveDifferentTypes(members[j])); } } } currentContract = currentContract.BaseContract; } return(false); }
internal XmlFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract) { return(_helper.GenerateClassWriter(classContract)); }
private int WriteMembers(ClassDataContract classContract, LocalBuilder extensionDataLocal, ClassDataContract derivedMostClassContract) { int memberCount = (classContract.BaseContract == null) ? 0 : WriteMembers(classContract.BaseContract, extensionDataLocal, derivedMostClassContract); LocalBuilder namespaceLocal = _ilg.DeclareLocal(typeof(XmlDictionaryString), "ns"); if (_contractNamespacesLocal == null) { _ilg.Load(_dataContractArg); _ilg.LoadMember(XmlFormatGeneratorStatics.NamespaceProperty); } else { _ilg.LoadArrayElement(_contractNamespacesLocal, _typeIndex - 1); } _ilg.Store(namespaceLocal); _ilg.Call(_contextArg, XmlFormatGeneratorStatics.IncrementItemCountMethod, classContract.Members.Count); for (int i = 0; i < classContract.Members.Count; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; LocalBuilder memberValue = null; if (member.IsGetOnlyCollection) { _ilg.Load(_contextArg); _ilg.Call(XmlFormatGeneratorStatics.StoreIsGetOnlyCollectionMethod); } else { _ilg.Load(_contextArg); _ilg.Call(XmlFormatGeneratorStatics.ResetIsGetOnlyCollectionMethod); } if (!member.EmitDefaultValue) { memberValue = LoadMemberValue(member); _ilg.IfNotDefaultValue(memberValue); } bool writeXsiType = CheckIfMemberHasConflict(member, classContract, derivedMostClassContract); if (writeXsiType || !TryWritePrimitive(memberType, memberValue, member.MemberInfo, null /*arrayItemIndex*/, namespaceLocal, null /*nameLocal*/, i + _childElementIndex)) { WriteStartElement(memberType, classContract.Namespace, namespaceLocal, null /*nameLocal*/, i + _childElementIndex); if (classContract.ChildElementNamespaces[i + _childElementIndex] != null) { _ilg.Load(_xmlWriterArg); _ilg.LoadArrayElement(_childElementNamespacesLocal, i + _childElementIndex); _ilg.Call(XmlFormatGeneratorStatics.WriteNamespaceDeclMethod); } if (memberValue == null) { memberValue = LoadMemberValue(member); } WriteValue(memberValue, writeXsiType); WriteEndElement(); } if (classContract.HasExtensionData) { _ilg.Call(_contextArg, XmlFormatGeneratorStatics.WriteExtensionDataMethod, _xmlWriterArg, extensionDataLocal, memberCount); } if (!member.EmitDefaultValue) { if (member.IsRequired) { _ilg.Else(); _ilg.Call(null, XmlFormatGeneratorStatics.ThrowRequiredMemberMustBeEmittedMethod, member.Name, classContract.UnderlyingType); } _ilg.EndIf(); } } _typeIndex++; _childElementIndex += classContract.Members.Count; return(memberCount); }
private int WriteMembers(ClassDataContract classContract, LocalBuilder extensionDataLocal, ClassDataContract derivedMostClassContract) { int memberCount = (classContract.BaseContract == null) ? 0 : WriteMembers(classContract.BaseContract, extensionDataLocal, derivedMostClassContract); int classMemberCount = classContract.Members.Count; _ilg.Call(thisObj: _contextArg, XmlFormatGeneratorStatics.IncrementItemCountMethod, classMemberCount); for (int i = 0; i < classMemberCount; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; LocalBuilder memberValue = null; _ilg.Load(_contextArg); _ilg.Call(methodInfo: member.IsGetOnlyCollection ? XmlFormatGeneratorStatics.StoreIsGetOnlyCollectionMethod : XmlFormatGeneratorStatics.ResetIsGetOnlyCollectionMethod); if (!member.EmitDefaultValue) { memberValue = LoadMemberValue(member); _ilg.IfNotDefaultValue(memberValue); } bool requiresNameAttribute = DataContractJsonSerializerImpl.CheckIfXmlNameRequiresMapping(classContract.MemberNames[i]); if (requiresNameAttribute || !TryWritePrimitive(memberType, memberValue, member.MemberInfo, arrayItemIndex: null, name: null, nameIndex: i + _childElementIndex)) { // Note: DataContractSerializer has member-conflict logic here to deal with the schema export // requirement that the same member can't be of two different types. if (requiresNameAttribute) { _ilg.Call(thisObj: null, JsonFormatGeneratorStatics.WriteJsonNameWithMappingMethod, _xmlWriterArg, _memberNamesArg, i + _childElementIndex); } else { WriteStartElement(nameLocal: null, nameIndex: i + _childElementIndex); } if (memberValue == null) { memberValue = LoadMemberValue(member); } WriteValue(memberValue); WriteEndElement(); } if (classContract.HasExtensionData) { _ilg.Call(thisObj: _contextArg, XmlFormatGeneratorStatics.WriteExtensionDataMethod, _xmlWriterArg, extensionDataLocal, memberCount); } if (!member.EmitDefaultValue) { if (member.IsRequired) { _ilg.Else(); _ilg.Call(thisObj: null, XmlFormatGeneratorStatics.ThrowRequiredMemberMustBeEmittedMethod, member.Name, classContract.UnderlyingType); } _ilg.EndIf(); } } _typeIndex++; _childElementIndex += classMemberCount; return(memberCount); }
public JsonFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract) { _ilg = new CodeGenerator(); bool memberAccessFlag = classContract.RequiresMemberAccessForRead(null); try { BeginMethod(_ilg, "Read" + DataContract.SanitizeTypeName(classContract.StableName.Name) + "FromJson", typeof(JsonFormatClassReaderDelegate), memberAccessFlag); } catch (SecurityException securityException) { if (memberAccessFlag) { classContract.RequiresMemberAccessForRead(securityException); } else { throw; } } InitArgs(); CreateObject(classContract); _ilg.Call(_contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, _objectLocal); InvokeOnDeserializing(classContract); if (classContract.IsISerializable) { ReadISerializable(classContract); } else { ReadClass(classContract); } if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom(classContract.UnderlyingType)) { _ilg.Call(_objectLocal, JsonFormatGeneratorStatics.OnDeserializationMethod, null); } InvokeOnDeserialized(classContract); if (!InvokeFactoryMethod(classContract)) { _ilg.Load(_objectLocal); // 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) { _ilg.ConvertValue(_objectLocal.LocalType, Globals.TypeOfDateTimeOffsetAdapter); _ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetMethod); _ilg.ConvertValue(Globals.TypeOfDateTimeOffset, _ilg.CurrentMethod.ReturnType); } //Copy the KeyValuePairAdapter<K,T> to a KeyValuePair<K,T>. else if (classContract.IsKeyValuePairAdapter) { _ilg.Call(classContract.GetKeyValuePairMethodInfo); _ilg.ConvertValue(Globals.TypeOfKeyValuePair.MakeGenericType(classContract.KeyValuePairGenericArguments), _ilg.CurrentMethod.ReturnType); } else { _ilg.ConvertValue(_objectLocal.LocalType, _ilg.CurrentMethod.ReturnType); } } return((JsonFormatClassReaderDelegate)_ilg.EndMethod()); }
public JsonClassDataContractCriticalHelper(ClassDataContract traditionalDataContract) : base(traditionalDataContract) { _typeName = string.IsNullOrEmpty(traditionalDataContract.Namespace.Value) ? traditionalDataContract.Name.Value : string.Concat(traditionalDataContract.Name.Value, JsonGlobals.NameValueSeparatorString, XmlObjectSerializerWriteContextComplexJson.TruncateDefaultDataContractNamespace(traditionalDataContract.Namespace.Value)); _traditionalClassDataContract = traditionalDataContract; CopyMembersAndCheckDuplicateNames(); }
protected override string GetClassContractNamespace(ClassDataContract classContract) { return(classContract.StableName !.Namespace); }
public XmlFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract) { return(_helper.GenerateClassReader(classContract)); }
private void ExportClassDataContract(ClassDataContract classDataContract, XmlSchema schema) { XmlSchemaComplexType type = new XmlSchemaComplexType(); type.Name = classDataContract.StableName.Name; schema.Items.Add(type); XmlElement?genericInfoElement = null; if (classDataContract.UnderlyingType.IsGenericType) { genericInfoElement = ExportGenericInfo(classDataContract.UnderlyingType, Globals.GenericTypeLocalName, Globals.SerializationNamespace); } XmlSchemaSequence rootSequence = new XmlSchemaSequence(); for (int i = 0; i < classDataContract.Members !.Count; i++) { DataMember dataMember = classDataContract.Members[i]; XmlSchemaElement element = new XmlSchemaElement(); element.Name = dataMember.Name; XmlElement? actualTypeElement = null; DataContract memberTypeContract = DataContractSet.GetMemberTypeDataContract(dataMember); if (CheckIfMemberHasConflict(dataMember)) { element.SchemaTypeName = AnytypeQualifiedName; actualTypeElement = ExportActualType(memberTypeContract.StableName); SchemaHelper.AddSchemaImport(memberTypeContract.StableName.Namespace, schema); } else { SetElementType(element, memberTypeContract, schema); } SchemaHelper.AddElementForm(element, schema); if (dataMember.IsNullable) { element.IsNillable = true; } if (!dataMember.IsRequired) { element.MinOccurs = 0; } element.Annotation = GetSchemaAnnotation(actualTypeElement, ExportSurrogateData(dataMember), ExportEmitDefaultValue(dataMember)); rootSequence.Items.Add(element); } XmlElement?isValueTypeElement = null; if (classDataContract.BaseContract != null) { XmlSchemaComplexContentExtension extension = CreateTypeContent(type, classDataContract.BaseContract.StableName, schema); extension.Particle = rootSequence; if (classDataContract.IsReference && !classDataContract.BaseContract.IsReference) { AddReferenceAttributes(extension.Attributes, schema); } } else { type.Particle = rootSequence; if (classDataContract.IsValueType) { isValueTypeElement = GetAnnotationMarkup(IsValueTypeName, XmlConvert.ToString(classDataContract.IsValueType), schema); } if (classDataContract.IsReference) { AddReferenceAttributes(type.Attributes, schema); } } type.Annotation = GetSchemaAnnotation(genericInfoElement, ExportSurrogateData(classDataContract), isValueTypeElement); }
private void ImportDataMembers() { Type type = this.UnderlyingType; FieldInfo[] fields = type.GetFields(BindingFlags.Static | BindingFlags.Public); Dictionary <string, DataMember> memberValuesTable = new Dictionary <string, DataMember>(); List <DataMember> tempMembers = new List <DataMember>(fields.Length); List <long> tempValues = new List <long>(fields.Length); for (int i = 0; i < fields.Length; i++) { FieldInfo field = fields[i]; bool enumMemberValid = false; if (_hasDataContract) { object[] memberAttributes = field.GetCustomAttributes(Globals.TypeOfEnumMemberAttribute, false).ToArray(); if (memberAttributes != null && memberAttributes.Length > 0) { if (memberAttributes.Length > 1) { ThrowInvalidDataContractException(SR.Format(SR.TooManyEnumMembers, DataContract.GetClrTypeFullName(field.DeclaringType), field.Name)); } EnumMemberAttribute memberAttribute = (EnumMemberAttribute)memberAttributes[0]; DataMember memberContract = new DataMember(field); if (memberAttribute.IsValueSetExplicitly) { if (memberAttribute.Value == null || memberAttribute.Value.Length == 0) { ThrowInvalidDataContractException(SR.Format(SR.InvalidEnumMemberValue, field.Name, DataContract.GetClrTypeFullName(type))); } memberContract.Name = memberAttribute.Value; } else { memberContract.Name = field.Name; } ClassDataContract.CheckAndAddMember(tempMembers, memberContract, memberValuesTable); enumMemberValid = true; } object[] dataMemberAttributes = field.GetCustomAttributes(Globals.TypeOfDataMemberAttribute, false).ToArray(); if (dataMemberAttributes != null && dataMemberAttributes.Length > 0) { ThrowInvalidDataContractException(SR.Format(SR.DataMemberOnEnumField, DataContract.GetClrTypeFullName(field.DeclaringType), field.Name)); } } else { if (!field.IsNotSerialized) { DataMember memberContract = new DataMember(field); memberContract.Name = field.Name; ClassDataContract.CheckAndAddMember(tempMembers, memberContract, memberValuesTable); enumMemberValid = true; } } if (enumMemberValid) { object enumValue = field.GetValue(null); if (_isULong) { tempValues.Add((long)Convert.ToUInt64(enumValue, null)); } else { tempValues.Add(Convert.ToInt64(enumValue, null)); } } } Interlocked.MemoryBarrier(); _members = tempMembers; _values = tempValues; }
public static Dictionary <string, object> ConvertClassDataContractToDictionary(DataContractJsonSerializer serializer, ClassDataContract dataContract, object value, XmlObjectSerializerWriteContextComplexJson context, bool writeServerType) { Dictionary <string, object> classToDictionary = new Dictionary <string, object>(); if (writeServerType) { AddTypeInformation(classToDictionary, DataContract.GetDataContract(value.GetType())); } if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter) { DateTimeOffset dto = (DateTimeOffset)value; classToDictionary["DateTime"] = dto.UtcDateTime; classToDictionary["OffsetMinutes"] = (short)dto.Offset.TotalMinutes; return(classToDictionary); } else if (dataContract.IsKeyValuePairAdapter) { //Convert KeyValuePair<K,T> to KeyValuePairAdapter<K,T> value = dataContract.KeyValuePairAdapterConstructorInfo.Invoke(new object[] { value }); } DataContractJsonSerializer.InvokeOnSerializing(value, dataContract, context); WriteClassDataContractMembers(serializer, dataContract, ref classToDictionary, value, context); DataContractJsonSerializer.InvokeOnSerialized(value, dataContract, context); return(classToDictionary); }
public void ReflectionWriteClass(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, ClassDataContract classContract, XmlDictionaryString[] memberNames) { _reflectionClassWriter.ReflectionWriteClass(xmlWriter, obj, context, classContract, memberNames); }
private bool InvokeFactoryMethod(ClassDataContract classContract) { return(false); }
private int WriteMembers(ClassDataContract classContract, LocalBuilder?extensionDataLocal, ClassDataContract derivedMostClassContract) { int memberCount = (classContract.BaseClassContract == null) ? 0 : WriteMembers(classContract.BaseClassContract, extensionDataLocal, derivedMostClassContract); LocalBuilder namespaceLocal = _ilg.DeclareLocal(typeof(XmlDictionaryString), "ns"); if (_contractNamespacesLocal == null) { _ilg.Load(_dataContractArg); _ilg.LoadMember(XmlFormatGeneratorStatics.NamespaceProperty); } else { _ilg.LoadArrayElement(_contractNamespacesLocal, _typeIndex - 1); } _ilg.Store(namespaceLocal); int classMemberCount = classContract.Members !.Count; _ilg.Call(thisObj: _contextArg, XmlFormatGeneratorStatics.IncrementItemCountMethod, classMemberCount); for (int i = 0; i < classMemberCount; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; LocalBuilder?memberValue = null; _ilg.Load(_contextArg); _ilg.Call(methodInfo: member.IsGetOnlyCollection ? XmlFormatGeneratorStatics.StoreIsGetOnlyCollectionMethod : XmlFormatGeneratorStatics.ResetIsGetOnlyCollectionMethod); if (!member.EmitDefaultValue) { memberValue = LoadMemberValue(member); _ilg.IfNotDefaultValue(memberValue); } bool writeXsiType = CheckIfMemberHasConflict(member, classContract, derivedMostClassContract); if (writeXsiType || !TryWritePrimitive(memberType, memberValue, member.MemberInfo, arrayItemIndex: null, ns: namespaceLocal, name: null, nameIndex: i + _childElementIndex)) { WriteStartElement(memberType, classContract.Namespace, namespaceLocal, nameLocal: null, nameIndex: i + _childElementIndex); if (classContract.ChildElementNamespaces ![i + _childElementIndex] != null)
protected override int ReflectionWriteMembers(XmlWriterDelegator xmlWriter, object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract, ClassDataContract derivedMostClassContract, int childElementIndex, XmlDictionaryString[] emptyStringArray) { int memberCount = (classContract.BaseContract == null) ? 0 : ReflectionWriteMembers(xmlWriter, obj, context, classContract.BaseContract, derivedMostClassContract, childElementIndex, emptyStringArray); childElementIndex += memberCount; Type classType = classContract.UnadaptedClassType; XmlDictionaryString[] memberNames = classContract.MemberNames; XmlDictionaryString ns = classContract.Namespace; context.IncrementItemCount(classContract.Members.Count); for (int i = 0; i < classContract.Members.Count; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; if (member.IsGetOnlyCollection) { context.StoreIsGetOnlyCollection(); } bool shouldWriteValue = true; object memberValue = null; if (!member.EmitDefaultValue) { memberValue = ReflectionGetMemberValue(obj, member); object defaultValue = XmlFormatGeneratorStatics.GetDefaultValue(memberType); if ((memberValue == null && defaultValue == null) || (memberValue != null && memberValue.Equals(defaultValue))) { shouldWriteValue = false; if (member.IsRequired) { XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(member.Name, classContract.UnderlyingType); } } } if (shouldWriteValue) { bool writeXsiType = CheckIfMemberHasConflict(member, classContract, derivedMostClassContract); if (memberValue == null) { memberValue = ReflectionGetMemberValue(obj, member); } PrimitiveDataContract primitiveContract = member.MemberPrimitiveContract; if (writeXsiType || !ReflectionTryWritePrimitive(xmlWriter, context, memberType, memberValue, memberNames[i + childElementIndex] /*name*/, ns, primitiveContract)) { ReflectionWriteStartElement(xmlWriter, memberType, ns, ns.Value, member.Name, 0); if (classContract.ChildElementNamespaces[i + childElementIndex] != null) { var nsChildElement = classContract.ChildElementNamespaces[i + childElementIndex]; xmlWriter.WriteNamespaceDecl(nsChildElement); } ReflectionWriteValue(xmlWriter, context, memberType, memberValue, writeXsiType, primitiveContractForParamType: null); ReflectionWriteEndElement(xmlWriter); } if (classContract.HasExtensionData) { context.WriteExtensionData(xmlWriter, ((IExtensibleDataObject)obj).ExtensionData, memberCount); } } } return(memberCount); }
private void ThrowIfCannotSerializeReadOnlyTypes(ClassDataContract classContract) { ThrowIfCannotSerializeReadOnlyTypes(XmlFormatGeneratorStatics.ClassSerializationExceptionMessageProperty); }
internal object ConvertDataContractToObject(object value, DataContract contract, XmlObjectSerializerWriteContextComplexJson context, bool writeServerType, RuntimeTypeHandle declaredTypeHandle) { if (context != null) { context.OnHandleReference(null /*XmlWriter*/, value, true); // canContainReferences } try { if (contract is ObjectDataContract) { Type valueType = value.GetType(); if (valueType != Globals.TypeOfObject) { return(ConvertDataContractToObject(value, DataContract.GetDataContract(valueType), context, true, contract.UnderlyingType.TypeHandle)); } else { return(value); } } else if (contract is TimeSpanDataContract) { return(XmlConvert.ToString((TimeSpan)value)); } else if (contract is QNameDataContract) { XmlQualifiedName qname = (XmlQualifiedName)value; return((qname.IsEmpty) ? string.Empty : (qname.Name + ":" + qname.Namespace)); } else if (contract is PrimitiveDataContract) { return(value); } else if (contract is CollectionDataContract) { CollectionDataContract collectionContract = contract as CollectionDataContract; switch (collectionContract.Kind) { case CollectionKind.GenericDictionary: case CollectionKind.Dictionary: return(DataContractToObjectConverter.ConvertGenericDictionaryToArray(this, (IEnumerable)value, collectionContract, context, writeServerType)); default: return(DataContractToObjectConverter.ConvertGenericListToArray(this, (IEnumerable)value, collectionContract, context, writeServerType)); } } else if (contract is ClassDataContract) { ClassDataContract classContract = contract as ClassDataContract; if (Globals.TypeOfScriptObject_IsAssignableFrom(classContract.UnderlyingType)) { return(ConvertScriptObjectToObject(value)); } return(DataContractToObjectConverter.ConvertClassDataContractToDictionary(this, (ClassDataContract)contract, value, context, writeServerType)); } else if (contract is EnumDataContract) { if (((EnumDataContract)contract).IsULong) { return(Convert.ToUInt64(value, null)); } else { return(Convert.ToInt64(value, null)); } } else if (contract is XmlDataContract) { DataContractSerializer dataContractSerializer = new DataContractSerializer(Type.GetTypeFromHandle(declaredTypeHandle), GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList)); MemoryStream memoryStream = new MemoryStream(); dataContractSerializer.WriteObject(memoryStream, value); memoryStream.Position = 0; return(new StreamReader(memoryStream, Encoding.UTF8).ReadToEnd()); } } finally { if (context != null) { context.OnEndHandleReference(null /*XmlWriter*/, value, true); // canContainReferences } } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.UnknownDataContract, contract.Name))); }
private void ReadSimpleDictionary(CollectionDataContract collectionContract, Type keyValueType) { Type[] keyValueTypes = keyValueType.GetGenericArguments(); Type keyType = keyValueTypes[0]; Type valueType = keyValueTypes[1]; int keyTypeNullableDepth = 0; Type keyTypeOriginal = keyType; 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) { ThrowSerializationException( SR.Format( SR.KeyTypeCannotBeParsedInSimpleDictionary, DataContract.GetClrTypeFullName(collectionContract.UnderlyingType), DataContract.GetClrTypeFullName(keyType))); } else { LocalBuilder nodeType = _ilg.DeclareLocal(typeof(XmlNodeType), "nodeType"); _ilg.BeginWhileCondition(); _ilg.Call(_xmlReaderArg, JsonFormatGeneratorStatics.MoveToContentMethod); _ilg.Stloc(nodeType); _ilg.Load(nodeType); _ilg.Load(XmlNodeType.EndElement); _ilg.BeginWhileBody(Cmp.NotEqualTo); _ilg.Load(nodeType); _ilg.Load(XmlNodeType.Element); _ilg.If(Cmp.NotEqualTo); ThrowUnexpectedStateException(XmlNodeType.Element); _ilg.EndIf(); _ilg.Call(_contextArg, XmlFormatGeneratorStatics.IncrementItemCountMethod, 1); if (keyParseMode == KeyParseMode.UsingParseEnum) { _ilg.Load(keyType); } _ilg.Load(_xmlReaderArg); _ilg.Call(JsonFormatGeneratorStatics.GetJsonMemberNameMethod); if (keyParseMode == KeyParseMode.UsingParseEnum) { _ilg.Call(JsonFormatGeneratorStatics.ParseEnumMethod); _ilg.ConvertValue(Globals.TypeOfObject, keyType); } else if (keyParseMode == KeyParseMode.UsingCustomParse) { _ilg.Call(keyDataContract.ParseMethod); } LocalBuilder pairKey = _ilg.DeclareLocal(keyType, "key"); _ilg.Stloc(pairKey); if (keyTypeNullableDepth > 0) { LocalBuilder pairKeyNullable = _ilg.DeclareLocal(keyTypeOriginal, "keyOriginal"); WrapNullableObject(pairKey, pairKeyNullable, keyTypeNullableDepth); pairKey = pairKeyNullable; } LocalBuilder pairValue = ReadValue(valueType, string.Empty); StoreKeyValuePair(_objectLocal, collectionContract, pairKey, pairValue); _ilg.EndWhile(); } }
public XmlFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract) { if (DataContractSerializer.Option == SerializationOption.ReflectionOnly) { return(CreateReflectionXmlClassReader(classContract)); } else { _ilg = new CodeGenerator(); bool memberAccessFlag = classContract.RequiresMemberAccessForRead(null); try { _ilg.BeginMethod("Read" + classContract.StableName.Name + "FromXml", Globals.TypeOfXmlFormatClassReaderDelegate, memberAccessFlag); } catch (SecurityException securityException) { if (memberAccessFlag) { classContract.RequiresMemberAccessForRead(securityException); } else { throw; } } InitArgs(); CreateObject(classContract); _ilg.Call(_contextArg, XmlFormatGeneratorStatics.AddNewObjectMethod, _objectLocal); InvokeOnDeserializing(classContract); LocalBuilder?objectId = null; if (HasFactoryMethod(classContract)) { objectId = _ilg.DeclareLocal(Globals.TypeOfString, "objectIdRead"); _ilg.Call(_contextArg, XmlFormatGeneratorStatics.GetObjectIdMethod); _ilg.Stloc(objectId); } if (classContract.IsISerializable) { ReadISerializable(classContract); } else { ReadClass(classContract); } _ = InvokeFactoryMethod(classContract, objectId); if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom(classContract.UnderlyingType)) { _ilg.Call(_objectLocal, XmlFormatGeneratorStatics.OnDeserializationMethod, null); } InvokeOnDeserialized(classContract); if (objectId == null) { _ilg.Load(_objectLocal); // 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) { _ilg.ConvertValue(_objectLocal.LocalType, Globals.TypeOfDateTimeOffsetAdapter); _ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetMethod); _ilg.ConvertValue(Globals.TypeOfDateTimeOffset, _ilg.CurrentMethod.ReturnType); } //Copy the KeyValuePairAdapter<K,T> to a KeyValuePair<K,T>. else if (classContract.IsKeyValuePairAdapter) { _ilg.Call(classContract.GetKeyValuePairMethodInfo); _ilg.ConvertValue(Globals.TypeOfKeyValuePair.MakeGenericType(classContract.KeyValuePairGenericArguments), _ilg.CurrentMethod.ReturnType); } else { _ilg.ConvertValue(_objectLocal.LocalType, _ilg.CurrentMethod.ReturnType); } } return((XmlFormatClassReaderDelegate)_ilg.EndMethod()); } }
protected override void ReflectionReadMembers(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[]?memberNamespaces, ClassDataContract classContract, ref object obj) { Debug.Assert(memberNamespaces != null); int memberCount = classContract.MemberNames !.Length; context.IncrementItemCount(memberCount); int memberIndex = -1; int firstRequiredMember; _ = GetRequiredMembers(classContract, out firstRequiredMember); bool hasRequiredMembers = (firstRequiredMember < memberCount); int requiredIndex = hasRequiredMembers ? firstRequiredMember : -1; DataMember[] members = new DataMember[memberCount]; int reflectedMemberCount = ReflectionGetMembers(classContract, members); Debug.Assert(reflectedMemberCount == memberCount, "The value returned by ReflectionGetMembers() should equal to memberCount."); ExtensionDataObject?extensionData = null; if (classContract.HasExtensionData) { extensionData = new ExtensionDataObject(); ((IExtensibleDataObject)obj).ExtensionData = extensionData; } while (true) { if (!XmlObjectSerializerReadContext.MoveToNextElement(xmlReader)) { return; } if (hasRequiredMembers) { memberIndex = context.GetMemberIndexWithRequiredMembers(xmlReader, memberNames, memberNamespaces, memberIndex, requiredIndex, extensionData); } else { memberIndex = context.GetMemberIndex(xmlReader, memberNames, memberNamespaces, memberIndex, extensionData); } // GetMemberIndex returns memberNames.Length if member not found if (memberIndex < members.Length) { ReflectionReadMember(xmlReader, context, classContract, ref obj, memberIndex, members); requiredIndex = memberIndex + 1; } } }
void InvokeOnSerialized(ClassDataContract classContract) { if (classContract.BaseContract != null) InvokeOnSerialized(classContract.BaseContract); if (classContract.OnSerialized != null) { ilg.LoadAddress(objectLocal); ilg.Load(contextArg); ilg.Call(XmlFormatGeneratorStatics.GetStreamingContextMethod); ilg.Call(classContract.OnSerialized); } }
public JsonFormatClassReaderDelegate GenerateClassReader(ClassDataContract classContract) { return(this.helper.GenerateClassReader(classContract)); }
int WriteMembers(ClassDataContract classContract, LocalBuilder extensionDataLocal, ClassDataContract derivedMostClassContract) { int memberCount = (classContract.BaseContract == null) ? 0 : WriteMembers(classContract.BaseContract, extensionDataLocal, derivedMostClassContract); ilg.Call(contextArg, XmlFormatGeneratorStatics.IncrementItemCountMethod, classContract.Members.Count); for (int i = 0; i < classContract.Members.Count; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; LocalBuilder memberValue = null; if (member.IsGetOnlyCollection) { ilg.Load(contextArg); ilg.Call(XmlFormatGeneratorStatics.StoreIsGetOnlyCollectionMethod); } if (!member.EmitDefaultValue) { memberValue = LoadMemberValue(member); ilg.IfNotDefaultValue(memberValue); } bool requiresNameAttribute = DataContractJsonSerializer.CheckIfXmlNameRequiresMapping(classContract.MemberNames[i]); if (requiresNameAttribute || !TryWritePrimitive(memberType, memberValue, member.MemberInfo, null /*arrayItemIndex*/, null /*nameLocal*/, i + childElementIndex)) { // Note: DataContractSerializer has member-conflict logic here to deal with the schema export // requirement that the same member can't be of two different types. if (requiresNameAttribute) { ilg.Call(null, JsonFormatGeneratorStatics.WriteJsonNameWithMappingMethod, xmlWriterArg, memberNamesArg, i + childElementIndex); } else { WriteStartElement(null /*nameLocal*/, i + childElementIndex); } if (memberValue == null) memberValue = LoadMemberValue(member); WriteValue(memberValue); WriteEndElement(); } if (classContract.HasExtensionData) ilg.Call(contextArg, XmlFormatGeneratorStatics.WriteExtensionDataMethod, xmlWriterArg, extensionDataLocal, memberCount); if (!member.EmitDefaultValue) { if (member.IsRequired) { ilg.Else(); ilg.Call(null, XmlFormatGeneratorStatics.ThrowRequiredMemberMustBeEmittedMethod, member.Name, classContract.UnderlyingType); } ilg.EndIf(); } } typeIndex++; childElementIndex += classContract.Members.Count; return memberCount; }
private bool HasFactoryMethod(ClassDataContract classContract) { return(Globals.TypeOfIObjectReference.IsAssignableFrom(classContract.UnderlyingType)); }
internal JsonFormatClassWriterDelegate GenerateClassWriter(ClassDataContract classContract) { ilg = new CodeGenerator(); bool memberAccessFlag = classContract.RequiresMemberAccessForWrite(null); try { BeginMethod(ilg, "Write" + classContract.StableName.Name + "ToJson", typeof(JsonFormatClassWriterDelegate), memberAccessFlag); } catch (SecurityException securityException) { if (memberAccessFlag && securityException.PermissionType.Equals(typeof(ReflectionPermission))) { classContract.RequiresMemberAccessForWrite(securityException); } else { throw; } } InitArgs(classContract.UnderlyingType); memberNamesArg = ilg.GetArg(4); DemandSerializationFormatterPermission(classContract); DemandMemberAccessPermission(memberAccessFlag); if (classContract.IsReadOnlyContract) { ThrowIfCannotSerializeReadOnlyTypes(classContract); } WriteClass(classContract); return (JsonFormatClassWriterDelegate)ilg.EndMethod(); }
private void ReadClass(ClassDataContract classContract) { ReadMembers(classContract, null /*extensionDataLocal*/); }
private int ReadMembers(ClassDataContract classContract, bool[] requiredMembers, Label[] memberLabels, LocalBuilder memberIndexLocal, LocalBuilder requiredIndexLocal) { int memberCount = (classContract.BaseContract == null) ? 0 : ReadMembers(classContract.BaseContract, requiredMembers, memberLabels, memberIndexLocal, requiredIndexLocal); for (int i = 0; i < classContract.Members.Count; i++, memberCount++) { DataMember dataMember = classContract.Members[i]; Type memberType = dataMember.MemberType; _ilg.Case(memberLabels[memberCount], dataMember.Name); if (dataMember.IsRequired) { int nextRequiredIndex = memberCount + 1; for (; nextRequiredIndex < requiredMembers.Length; nextRequiredIndex++) { if (requiredMembers[nextRequiredIndex]) { break; } } _ilg.Set(requiredIndexLocal, nextRequiredIndex); } LocalBuilder value = null; if (dataMember.IsGetOnlyCollection) { _ilg.LoadAddress(_objectLocal); _ilg.LoadMember(dataMember.MemberInfo); value = _ilg.DeclareLocal(memberType, dataMember.Name + "Value"); _ilg.Stloc(value); _ilg.Call(_contextArg, XmlFormatGeneratorStatics.StoreCollectionMemberInfoMethod, value); ReadValue(memberType, dataMember.Name, classContract.StableName.Namespace); } else { value = ReadValue(memberType, dataMember.Name, classContract.StableName.Namespace); _ilg.LoadAddress(_objectLocal); _ilg.ConvertAddress(_objectLocal.LocalType, _objectType); _ilg.Ldloc(value); _ilg.StoreMember(dataMember.MemberInfo); } #if FEATURE_LEGACYNETCF // The DataContractSerializer in the full framework doesn't support unordered elements: // deserialization will fail if the data members in the XML are not sorted alphabetically. // But the NetCF DataContractSerializer does support unordered element. To maintain compatibility // with Mango we always search for the member from the beginning of the member list. // We set memberIndexLocal to -1 because GetMemberIndex always starts from memberIndex+1. if (CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) { ilg.Set(memberIndexLocal, (int)-1); } else #endif // FEATURE_LEGACYNETCF _ilg.Set(memberIndexLocal, memberCount); _ilg.EndCase(); } return(memberCount); }