private bool CheckIfConflictingMembersHaveDifferentTypes(DataMember member) { while (member.ConflictingMember != null) { if (member.MemberType != member.ConflictingMember.MemberType) { return true; } member = member.ConflictingMember; } return false; }
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 DataContract GetMemberTypeDataContract(DataMember dataMember) { if (dataMember.MemberInfo != null) { Type dataMemberType = dataMember.MemberType; if (dataMember.IsGetOnlyCollection) { if (dataContractSurrogate != null) { Type dcType = DataContractSurrogateCaller.GetDataContractType(dataContractSurrogate, dataMemberType); if (dcType != dataMemberType) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.SurrogatesWithGetOnlyCollectionsNotSupported, DataContract.GetClrTypeFullName(dataMemberType), DataContract.GetClrTypeFullName(dataMember.MemberInfo.DeclaringType), dataMember.MemberInfo.Name))); } } return DataContract.GetGetOnlyCollectionDataContract(DataContract.GetId(dataMemberType.TypeHandle), dataMemberType.TypeHandle, dataMemberType, SerializationMode.SharedContract); } else { return GetDataContract(dataMemberType); } } return dataMember.MemberTypeContract; }
private XmlElement ExportEmitDefaultValue(DataMember dataMember) { if (dataMember.EmitDefaultValue) return null; XmlElement defaultValueElement = XmlDoc.CreateElement(DefaultValueAnnotation.Name, DefaultValueAnnotation.Namespace); XmlAttribute emitDefaultValueAttribute = XmlDoc.CreateAttribute(Globals.EmitDefaultValueAttribute); emitDefaultValueAttribute.Value = Globals.False; defaultValueElement.Attributes.Append(emitDefaultValueAttribute); return defaultValueElement; }
void ImportClassMember(XmlSchemaElement element, ClassDataContract dataContract) { XmlQualifiedName typeName = dataContract.StableName; if (element.MinOccurs > 1) ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.ElementMinOccursMustBe, element.Name)); if (element.MaxOccurs != 1) ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.ElementMaxOccursMustBe, element.Name)); DataContract memberTypeContract = null; string memberName = element.Name; bool memberIsRequired = (element.MinOccurs > 0); bool memberIsNullable = element.IsNillable; bool memberEmitDefaultValue; int memberOrder = 0; XmlSchemaForm elementForm = (element.Form == XmlSchemaForm.None) ? SchemaHelper.GetSchemaWithType(SchemaObjects, schemaSet, typeName).ElementFormDefault : element.Form; if (elementForm != XmlSchemaForm.Qualified) ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.FormMustBeQualified, element.Name)); CheckIfElementUsesUnsupportedConstructs(typeName, element); if (element.SchemaTypeName.IsEmpty) { if (element.SchemaType != null) memberTypeContract = ImportAnonymousElement(element, new XmlQualifiedName(String.Format(CultureInfo.InvariantCulture, "{0}.{1}Type", typeName.Name, element.Name), typeName.Namespace)); else if (!element.RefName.IsEmpty) ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.ElementRefOnLocalElementNotSupported, element.RefName.Name, element.RefName.Namespace)); else memberTypeContract = ImportType(SchemaExporter.AnytypeQualifiedName); } else { XmlQualifiedName memberTypeName = ImportActualType(element.Annotation, element.SchemaTypeName, typeName); memberTypeContract = ImportType(memberTypeName); if (IsObjectContract(memberTypeContract)) needToImportKnownTypesForObject = true; } bool? emitDefaultValueFromAnnotation = ImportEmitDefaultValue(element.Annotation, typeName); if (!memberTypeContract.IsValueType && !memberIsNullable) { if (emitDefaultValueFromAnnotation != null && emitDefaultValueFromAnnotation.Value) throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.InvalidEmitDefaultAnnotation, memberName, typeName.Name, typeName.Namespace))); memberEmitDefaultValue = false; } else memberEmitDefaultValue = emitDefaultValueFromAnnotation != null ? emitDefaultValueFromAnnotation.Value : Globals.DefaultEmitDefaultValue; int prevMemberIndex = dataContract.Members.Count - 1; if (prevMemberIndex >= 0) { DataMember prevMember = dataContract.Members[prevMemberIndex]; if (prevMember.Order > Globals.DefaultOrder) memberOrder = dataContract.Members.Count; DataMember currentMember = new DataMember(memberTypeContract, memberName, memberIsNullable, memberIsRequired, memberEmitDefaultValue, memberOrder); int compare = ClassDataContract.DataMemberComparer.Singleton.Compare(prevMember, currentMember); if (compare == 0) ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.CannotHaveDuplicateElementNames, memberName)); else if (compare > 0) memberOrder = dataContract.Members.Count; } DataMember dataMember = new DataMember(memberTypeContract, memberName, memberIsNullable, memberIsRequired, memberEmitDefaultValue, memberOrder); XmlQualifiedName surrogateDataAnnotationName = SchemaExporter.SurrogateDataAnnotationName; dataContractSet.SetSurrogateData(dataMember, ImportSurrogateData(ImportAnnotation(element.Annotation, surrogateDataAnnotationName), surrogateDataAnnotationName.Name, surrogateDataAnnotationName.Namespace)); dataContract.Members.Add(dataMember); }
private EnumDataContract ImportEnum(XmlQualifiedName typeName, XmlSchemaSimpleTypeRestriction restriction, bool isFlags, XmlSchemaAnnotation annotation) { EnumDataContract dataContract = new EnumDataContract { StableName = typeName, BaseContractName = ImportActualType(annotation, SchemaExporter.DefaultEnumBaseTypeName, typeName), IsFlags = isFlags }; this.AddDataContract(dataContract); dataContract.Values = new List<long>(); dataContract.Members = new List<DataMember>(); foreach (XmlSchemaFacet facet in restriction.Facets) { XmlSchemaEnumerationFacet facet2 = facet as XmlSchemaEnumerationFacet; if (facet2 == null) { ThrowEnumTypeCannotBeImportedException(typeName.Name, typeName.Namespace, System.Runtime.Serialization.SR.GetString("EnumOnlyEnumerationFacetsSupported")); } if (facet2.Value == null) { ThrowEnumTypeCannotBeImportedException(typeName.Name, typeName.Namespace, System.Runtime.Serialization.SR.GetString("EnumEnumerationFacetsMustHaveValue")); } string innerText = this.GetInnerText(typeName, ImportAnnotation(facet2.Annotation, SchemaExporter.EnumerationValueAnnotationName)); if (innerText == null) { dataContract.Values.Add(SchemaExporter.GetDefaultEnumValue(isFlags, dataContract.Members.Count)); } else { dataContract.Values.Add(dataContract.GetEnumValueFromString(innerText)); } DataMember item = new DataMember(facet2.Value); dataContract.Members.Add(item); } return dataContract; }
private void ImportDataMembers() { /* * DataMembers are used for the deserialization of Exceptions. * DataMembers represent the fields and/or settable properties that the underlying Exception has. * The DataMembers are stored and eventually passed to a ClassDataContract created from the underlying Exception. * The ClassDataContract uses the list of DataMembers to set the fields/properties for the newly created Exception. * If a DataMember is a property it must be settable. */ Type type = this.UnderlyingType; if (type == Globals.TypeOfException) { ImportSystemExceptionDataMembers(); //System.Exception must be handled specially because it is the only exception that imports private fields. return; } List<DataMember> tempMembers; if (BaseContract != null) { tempMembers = new List<DataMember>(BaseContract.Members); //Don't set tempMembers = BaseContract.Members and then start adding, because this alters the base's reference. } else { tempMembers = new List<DataMember>(); } Dictionary<string, DataMember> memberNamesTable = new Dictionary<string, DataMember>(); MemberInfo[] memberInfos; memberInfos = type.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public); for (int i = 0; i < memberInfos.Length; i++) { MemberInfo member = memberInfos[i]; //Public properties with set methods can be deserialized with the ClassDataContract PropertyInfo publicProperty = member as PropertyInfo; if (publicProperty != null && publicProperty.SetMethod != null) { DataMember memberContract = new DataMember(member); memberContract.Name = DataContract.EncodeLocalName(member.Name); memberContract.IsRequired = false; memberContract.IsNullable = DataContract.IsTypeNullable(memberContract.MemberType); if (HasNoConflictWithBaseMembers(memberContract)) { CheckAndAddMember(tempMembers, memberContract, memberNamesTable); } } } Interlocked.MemoryBarrier(); _members = tempMembers; }
private void ReflectionSetMemberValue(ref object obj, object memberValue, DataMember dataMember) { dataMember.Setter(ref obj, memberValue); }
private object ReflectionGetMemberValue(object obj, DataMember dataMember) { return(dataMember.Getter(obj)); }
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); } 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 (!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); }
public void WriteChildToContext(DataMember contextMember, string prefix) { _xPathBuilder.Append(XPathQueryGenerator.XPathSeparator + prefix + XPathQueryGenerator.NsSeparator + contextMember.Name); }
protected object ReflectionGetMemberValue(object obj, DataMember dataMember) { return dataMember.Getter(obj); }
protected object?ReflectionGetMemberValue(object obj, DataMember dataMember) { return(dataMember.Getter(obj)); }
private void ImportDataMembers() { Type underlyingType = base.UnderlyingType; FieldInfo[] fields = underlyingType.GetFields(BindingFlags.Public | BindingFlags.Static); Dictionary<string, DataMember> memberNamesTable = new Dictionary<string, DataMember>(); List<DataMember> members = new List<DataMember>(fields.Length); List<long> list2 = new List<long>(fields.Length); for (int i = 0; i < fields.Length; i++) { FieldInfo memberInfo = fields[i]; bool flag = false; if (this.hasDataContract) { object[] customAttributes = memberInfo.GetCustomAttributes(Globals.TypeOfEnumMemberAttribute, false); if ((customAttributes != null) && (customAttributes.Length > 0)) { if (customAttributes.Length > 1) { base.ThrowInvalidDataContractException(System.Runtime.Serialization.SR.GetString("TooManyEnumMembers", new object[] { DataContract.GetClrTypeFullName(memberInfo.DeclaringType), memberInfo.Name })); } EnumMemberAttribute attribute = (EnumMemberAttribute) customAttributes[0]; DataMember memberContract = new DataMember(memberInfo); if (attribute.IsValueSetExplicit) { if ((attribute.Value == null) || (attribute.Value.Length == 0)) { base.ThrowInvalidDataContractException(System.Runtime.Serialization.SR.GetString("InvalidEnumMemberValue", new object[] { memberInfo.Name, DataContract.GetClrTypeFullName(underlyingType) })); } memberContract.Name = attribute.Value; } else { memberContract.Name = memberInfo.Name; } ClassDataContract.CheckAndAddMember(members, memberContract, memberNamesTable); flag = true; } object[] objArray2 = memberInfo.GetCustomAttributes(Globals.TypeOfDataMemberAttribute, false); if ((objArray2 != null) && (objArray2.Length > 0)) { base.ThrowInvalidDataContractException(System.Runtime.Serialization.SR.GetString("DataMemberOnEnumField", new object[] { DataContract.GetClrTypeFullName(memberInfo.DeclaringType), memberInfo.Name })); } } else if (!memberInfo.IsNotSerialized) { DataMember member2 = new DataMember(memberInfo) { Name = memberInfo.Name }; ClassDataContract.CheckAndAddMember(members, member2, memberNamesTable); flag = true; } if (flag) { object obj2 = memberInfo.GetValue(null); if (this.isULong) { list2.Add((long) ((IConvertible) obj2).ToUInt64(null)); } else { list2.Add(((IConvertible) obj2).ToInt64(null)); } } } Thread.MemoryBarrier(); this.members = members; this.values = list2; }
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 { 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; }
private LocalBuilder LoadMemberValue(DataMember member) { ilg.LoadAddress(objectLocal); ilg.LoadMember(member.MemberInfo); LocalBuilder memberValue = ilg.DeclareLocal(member.MemberType, member.Name + "Value"); ilg.Stloc(memberValue); return memberValue; }
private object ReflectionReadValue(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, DataMember dataMember, string ns) { Type type = dataMember.MemberType; string name = dataMember.Name; return(ReflectionReadValue(xmlReader, context, type, name, ns, dataMember.MemberPrimitiveContract)); }
private bool HasNoConflictWithBaseMembers(DataMember memberContract) { //Don't add redundant members, this can happen if a property overrides it's base class implementation. Because the overridden property will appear as "declared" in that type. foreach (DataMember dm in BaseContract.Members) { if (dm.Name.Equals(memberContract.Name)) { return false; } } return true; }
int WriteMembers(ClassDataContract classContract, ExtensionDataObject extensionData, ClassDataContract derivedMostClassContract) { int memberCount = (classContract.BaseContract == null) ? 0 : WriteMembers(classContract.BaseContract, extensionData, derivedMostClassContract); XmlDictionaryString ns = (contractNamespaces == null) ? dataContract.Namespace : contractNamespaces [typeIndex - 1]; ctx.IncrementItemCount(classContract.Members.Count); for (int i = 0; i < classContract.Members.Count; i++, memberCount++) { DataMember member = classContract.Members[i]; Type memberType = member.MemberType; object memberValue = null; if (member.IsGetOnlyCollection) { ctx.StoreIsGetOnlyCollection(); } bool doWrite = true, hasMemberValue = false; if (!member.EmitDefaultValue) { hasMemberValue = true; memberValue = LoadMemberValue(member); doWrite = !IsDefaultValue(memberType, memberValue); } if (doWrite) { bool writeXsiType = CheckIfMemberHasConflict(member, classContract, derivedMostClassContract); if (writeXsiType || !TryWritePrimitive(memberType, hasMemberValue ? () => memberValue : (Func <object>)null, member.MemberInfo, null /*arrayItemIndex*/, ns, null /*nameLocal*/, i + childElementIndex)) { WriteStartElement(memberType, classContract.Namespace, ns, null /*nameLocal*/, i + childElementIndex); if (classContract.ChildElementNamespaces [i + childElementIndex] != null) { writer.WriteNamespaceDecl(childElementNamespaces [i + childElementIndex]); } if (memberValue == null) { memberValue = LoadMemberValue(member); } WriteValue(memberType, memberValue, writeXsiType); WriteEndElement(); } if (classContract.HasExtensionData) { ctx.WriteExtensionData(writer, extensionData, memberCount); } } else if (!member.EmitDefaultValue) { if (member.IsRequired) { XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(member.Name, classContract.UnderlyingType); } } } typeIndex++; childElementIndex += classContract.Members.Count; return(memberCount); }
EnumDataContract ImportEnum(XmlQualifiedName typeName, XmlSchemaSimpleTypeRestriction restriction, bool isFlags, XmlSchemaAnnotation annotation) { EnumDataContract dataContract = new EnumDataContract(); dataContract.StableName = typeName; dataContract.BaseContractName = ImportActualType(annotation, SchemaExporter.DefaultEnumBaseTypeName, typeName); dataContract.IsFlags = isFlags; AddDataContract(dataContract); // CheckIfEnum has already checked if baseType of restriction is string dataContract.Values = new List<long>(); dataContract.Members = new List<DataMember>(); foreach (XmlSchemaFacet facet in restriction.Facets) { XmlSchemaEnumerationFacet enumFacet = facet as XmlSchemaEnumerationFacet; if (enumFacet == null) ThrowEnumTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.EnumOnlyEnumerationFacetsSupported)); if (enumFacet.Value == null) ThrowEnumTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.EnumEnumerationFacetsMustHaveValue)); string valueInnerText = GetInnerText(typeName, ImportAnnotation(enumFacet.Annotation, SchemaExporter.EnumerationValueAnnotationName)); if (valueInnerText == null) dataContract.Values.Add(SchemaExporter.GetDefaultEnumValue(isFlags, dataContract.Members.Count)); else dataContract.Values.Add(dataContract.GetEnumValueFromString(valueInnerText)); DataMember dataMember = new DataMember(enumFacet.Value); dataContract.Members.Add(dataMember); } return dataContract; }
object LoadMemberValue(DataMember member) { return(CodeInterpreter.GetMember(member.MemberInfo, objLocal)); }
bool CheckIfMemberHasConflict(DataMember dataMember) { if (dataMember.HasConflictingNameAndType) return true; DataMember conflictingMember = dataMember.ConflictingMember; while (conflictingMember != null) { if (conflictingMember.HasConflictingNameAndType) return true; conflictingMember = conflictingMember.ConflictingMember; } return false; }
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); }
private static void PopulateReadOnlyCollection(object instance, DataMember member, IEnumerable value) { Debug.Assert(member.IsGetOnlyCollection); CollectionDataContract memberContract = (CollectionDataContract)member.MemberTypeContract; var collection = DataContractToObjectConverter.GetMemberValue(instance, member.MemberInfo, instance.GetType()); // Special case an array var array = collection as Array; if (array != null) { Array srcArray = (Array)value; Type elementType = srcArray.GetType().GetElementType(); // Resize var resizeMethod = typeof(Array).GetMethod("Resize", BindingFlags.Static | BindingFlags.Public); var properResizeMethod = resizeMethod.MakeGenericMethod(elementType); properResizeMethod.Invoke(null, new object[] { array, srcArray.Length }); // Copy Array.Copy(srcArray, 0, array, 0, srcArray.Length); return; } // General collection IEnumerator enumerator = value.GetEnumerator(); object currentItem = null; object[] currentItemArray = null; while (enumerator.MoveNext()) { currentItem = enumerator.Current; currentItemArray = new object[] { currentItem }; // Dictionary if (memberContract.IsDictionary) { 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) }; } memberContract.AddMethod.Invoke(collection, currentItemArray); } }
private bool CheckIfMemberHasConflict(DataMember dataMember) { if (dataMember.HasConflictingNameAndType) { return true; } for (DataMember member = dataMember.ConflictingMember; member != null; member = member.ConflictingMember) { if (member.HasConflictingNameAndType) { return true; } } return false; }
internal DataMember BindGenericParameters(DataContract[] paramContracts, Dictionary<DataContract, DataContract> boundContracts) { DataContract memberTypeContract = this.MemberTypeContract.BindGenericParameters(paramContracts, boundContracts); DataMember boundDataMember = new DataMember(memberTypeContract, this.Name, !memberTypeContract.IsValueType, this.IsRequired, this.EmitDefaultValue, this.Order); return boundDataMember; }
private XmlElement ExportEmitDefaultValue(DataMember dataMember) { if (dataMember.EmitDefaultValue) { return null; } XmlElement element = this.XmlDoc.CreateElement(DefaultValueAnnotation.Name, DefaultValueAnnotation.Namespace); System.Xml.XmlAttribute node = this.XmlDoc.CreateAttribute("EmitDefaultValue"); node.Value = "false"; element.Attributes.Append(node); return element; }
private LocalBuilder LoadMemberValue(DataMember member) { this.ilg.LoadAddress(this.objectLocal); this.ilg.LoadMember(member.MemberInfo); LocalBuilder local = this.ilg.DeclareLocal(member.MemberType, member.Name + "Value"); this.ilg.Stloc(local); return local; }
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); }
internal DataContract GetMemberTypeDataContract(DataMember dataMember) { if (dataMember.MemberInfo == null) { return dataMember.MemberTypeContract; } Type memberType = dataMember.MemberType; if (!dataMember.IsGetOnlyCollection) { return this.GetDataContract(memberType); } if ((this.dataContractSurrogate != null) && (DataContractSurrogateCaller.GetDataContractType(this.dataContractSurrogate, memberType) != memberType)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(System.Runtime.Serialization.SR.GetString("SurrogatesWithGetOnlyCollectionsNotSupported", new object[] { DataContract.GetClrTypeFullName(memberType), DataContract.GetClrTypeFullName(dataMember.MemberInfo.DeclaringType), dataMember.MemberInfo.Name }))); } return DataContract.GetGetOnlyCollectionDataContract(DataContract.GetId(memberType.TypeHandle), memberType.TypeHandle, memberType, SerializationMode.SharedContract); }
public void WriteChildToContext(DataMember contextMember, string prefix) { this.xPathBuilder.Append("/" + prefix + ":" + contextMember.Name); }
public void WriteChildToContext(DataMember contextMember, string prefix) { this.xPathBuilder.Append(XPathQueryGenerator.XPathSeparator + prefix + XPathQueryGenerator.NsSeparator + contextMember.Name); }
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; }
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; }
object LoadMemberValue (DataMember member) { return CodeInterpreter.GetMember (member.MemberInfo, objLocal); }
private void ImportSystemExceptionDataMembers() { /* * The data members imported for System.Exception are private fields. They must be treated specially. * The EssentialExceptionFields Dictionary keeps track of which private fields needs to be imported, and also the name that they should be serialized with. */ Type type = this.UnderlyingType; List<DataMember> tempMembers; tempMembers = new List<DataMember>(); Dictionary<string, DataMember> memberNamesTable = new Dictionary<string, DataMember>(); foreach (string fieldInfoName in EssentialExceptionFields.Keys) { FieldInfo member = type.GetField(fieldInfoName, BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance); if (CanSerializeMember(member)) { DataMember memberContract = new DataMember(member); memberContract.Name = DataContract.EncodeLocalName(member.Name); memberContract.IsRequired = false; memberContract.IsNullable = DataContract.IsTypeNullable(memberContract.MemberType); CheckAndAddMember(tempMembers, memberContract, memberNamesTable); } } Interlocked.MemoryBarrier(); _members = tempMembers; }
GenericInfo GetGenericInfoForDataMember(DataMember dataMember) { GenericInfo genericInfo = null; if (dataMember.MemberTypeContract.IsValueType && dataMember.IsNullable) { genericInfo = new GenericInfo(DataContract.GetStableName(Globals.TypeOfNullable), Globals.TypeOfNullable.FullName); genericInfo.Add(new GenericInfo(dataMember.MemberTypeContract.StableName, null)); } else { genericInfo = new GenericInfo(dataMember.MemberTypeContract.StableName, null); } return genericInfo; }
private static void CheckAndAddMember(List<DataMember> members, DataMember memberContract, Dictionary<string, DataMember> memberNamesTable) { DataMember existingMemberContract; if (memberNamesTable.TryGetValue(memberContract.Name, out existingMemberContract)) { Type declaringType = memberContract.MemberInfo.DeclaringType; DataContract.ThrowInvalidDataContractException( SR.Format(SR.DupMemberName, existingMemberContract.MemberInfo.Name, memberContract.MemberInfo.Name, DataContract.GetClrTypeFullName(declaringType), memberContract.Name), declaringType); } memberNamesTable.Add(memberContract.Name, memberContract); members.Add(memberContract); }
private void ImportClassMember(XmlSchemaElement element, ClassDataContract dataContract) { bool flag3; XmlQualifiedName stableName = dataContract.StableName; if (element.MinOccurs > 1M) { ThrowTypeCannotBeImportedException(stableName.Name, stableName.Namespace, System.Runtime.Serialization.SR.GetString("ElementMinOccursMustBe", new object[] { element.Name })); } if (element.MaxOccurs != 1M) { ThrowTypeCannotBeImportedException(stableName.Name, stableName.Namespace, System.Runtime.Serialization.SR.GetString("ElementMaxOccursMustBe", new object[] { element.Name })); } DataContract contract = null; string name = element.Name; bool isRequired = element.MinOccurs > 0M; bool isNillable = element.IsNillable; int order = 0; XmlSchemaForm form = (element.Form == XmlSchemaForm.None) ? SchemaHelper.GetSchemaWithType(this.SchemaObjects, this.schemaSet, stableName).ElementFormDefault : element.Form; if (form != XmlSchemaForm.Qualified) { ThrowTypeCannotBeImportedException(stableName.Name, stableName.Namespace, System.Runtime.Serialization.SR.GetString("FormMustBeQualified", new object[] { element.Name })); } this.CheckIfElementUsesUnsupportedConstructs(stableName, element); if (element.SchemaTypeName.IsEmpty) { if (element.SchemaType != null) { contract = this.ImportAnonymousElement(element, new XmlQualifiedName(string.Format(CultureInfo.InvariantCulture, "{0}.{1}Type", new object[] { stableName.Name, element.Name }), stableName.Namespace)); } else if (!element.RefName.IsEmpty) { ThrowTypeCannotBeImportedException(stableName.Name, stableName.Namespace, System.Runtime.Serialization.SR.GetString("ElementRefOnLocalElementNotSupported", new object[] { element.RefName.Name, element.RefName.Namespace })); } else { contract = this.ImportType(SchemaExporter.AnytypeQualifiedName); } } else { XmlQualifiedName typeName = ImportActualType(element.Annotation, element.SchemaTypeName, stableName); contract = this.ImportType(typeName); if (IsObjectContract(contract)) { this.needToImportKnownTypesForObject = true; } } bool? nullable = this.ImportEmitDefaultValue(element.Annotation, stableName); if (!contract.IsValueType && !isNillable) { if (nullable.HasValue && nullable.Value) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(System.Runtime.Serialization.SR.GetString("InvalidEmitDefaultAnnotation", new object[] { name, stableName.Name, stableName.Namespace }))); } flag3 = false; } else { flag3 = nullable.HasValue ? nullable.Value : true; } int num2 = dataContract.Members.Count - 1; if (num2 >= 0) { DataMember x = dataContract.Members[num2]; if (x.Order > 0) { order = dataContract.Members.Count; } DataMember y = new DataMember(contract, name, isNillable, isRequired, flag3, order); int num3 = ClassDataContract.DataMemberComparer.Singleton.Compare(x, y); if (num3 == 0) { ThrowTypeCannotBeImportedException(stableName.Name, stableName.Namespace, System.Runtime.Serialization.SR.GetString("CannotHaveDuplicateElementNames", new object[] { name })); } else if (num3 > 0) { order = dataContract.Members.Count; } } DataMember key = new DataMember(contract, name, isNillable, isRequired, flag3, order); XmlQualifiedName surrogateDataAnnotationName = SchemaExporter.SurrogateDataAnnotationName; this.dataContractSet.SetSurrogateData(key, this.ImportSurrogateData(ImportAnnotation(element.Annotation, surrogateDataAnnotationName), surrogateDataAnnotationName.Name, surrogateDataAnnotationName.Namespace)); dataContract.Members.Add(key); }