private object DeserializeTaggedDictionaryValue(XElement xelemValue, XName alias, Type type, YAXCollectionAttribute colAttributeInstance, YAXDictionaryAttribute dicAttrInstance) { // otherwise the "else if(member.IsTreatedAsCollection)" block solves the problem Type keyType, valueType; if (!ReflectionUtils.IsIDictionary(type, out keyType, out valueType)) { throw new Exception("elemValue must be a Dictionary"); } // deserialize non-collection fields var containerSer = new YAXSerializer(type, m_exceptionPolicy, m_defaultExceptionType, m_serializationOption); containerSer.m_documentDefaultNamespace = m_documentDefaultNamespace; containerSer.SetNamespaceToOverrideEmptyNamespace( alias.Namespace. IfEmptyThen(TypeNamespace). IfEmptyThenNone()); containerSer.IsCraetedToDeserializeANonCollectionMember = true; containerSer.RemoveDeserializedXmlNodes = true; object dic = containerSer.DeserializeBase(xelemValue); m_parsingErrors.AddRange(containerSer.ParsingErrors); // now try to deserialize collection fields Type pairType = null; ReflectionUtils.IsIEnumerable(type, out pairType); XName eachElementName = StringUtils.RefineSingleElement(ReflectionUtils.GetTypeFriendlyName(pairType)); bool isKeyAttrib = false; bool isValueAttrib = false; bool isKeyContent = false; bool isValueContent = false; XName keyAlias = alias.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone() + "Key"; XName valueAlias = alias.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone() + "Value"; if (colAttributeInstance != null && colAttributeInstance.EachElementName != null) { eachElementName = StringUtils.RefineSingleElement(colAttributeInstance.EachElementName); eachElementName = eachElementName.OverrideNsIfEmpty(alias.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); } if (dicAttrInstance != null) { if (dicAttrInstance.EachPairName != null) { eachElementName = StringUtils.RefineSingleElement(dicAttrInstance.EachPairName); eachElementName = eachElementName.OverrideNsIfEmpty(alias.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); } if (dicAttrInstance.SerializeKeyAs == YAXNodeTypes.Attribute) { isKeyAttrib = ReflectionUtils.IsBasicType(keyType); } else if (dicAttrInstance.SerializeKeyAs == YAXNodeTypes.Content) { isKeyContent = ReflectionUtils.IsBasicType(keyType); } if (dicAttrInstance.SerializeValueAs == YAXNodeTypes.Attribute) { isValueAttrib = ReflectionUtils.IsBasicType(valueType); } else if (dicAttrInstance.SerializeValueAs == YAXNodeTypes.Content) { isValueContent = ReflectionUtils.IsBasicType(valueType); } if (dicAttrInstance.KeyName != null) { keyAlias = StringUtils.RefineSingleElement(dicAttrInstance.KeyName); keyAlias = keyAlias.OverrideNsIfEmpty(alias.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); } if (dicAttrInstance.ValueName != null) { valueAlias = StringUtils.RefineSingleElement(dicAttrInstance.ValueName); valueAlias = valueAlias.OverrideNsIfEmpty(alias.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); } } foreach (XElement childElem in xelemValue.Elements(eachElementName)) { object key = null, value = null; YAXSerializer keySer = null, valueSer = null; bool isKeyFound = VerifyDictionaryPairElements(ref keyType, ref isKeyAttrib, ref isKeyContent, keyAlias, childElem); bool isValueFound = VerifyDictionaryPairElements(ref valueType, ref isValueAttrib, ref isValueContent, valueAlias, childElem); if (!isKeyFound && !isValueFound) continue; if (isKeyFound) { if (isKeyAttrib) { key = ReflectionUtils.ConvertBasicType(childElem.Attribute_NamespaceSafe(keyAlias, m_documentDefaultNamespace).Value, keyType); } else if (isKeyContent) { key = ReflectionUtils.ConvertBasicType(childElem.GetXmlContent(), keyType); } else if (ReflectionUtils.IsBasicType(keyType)) { key = ReflectionUtils.ConvertBasicType(childElem.Element(keyAlias).Value, keyType); } else { if (keySer == null) { keySer = new YAXSerializer(keyType, m_exceptionPolicy, m_defaultExceptionType, m_serializationOption); keySer.m_documentDefaultNamespace = m_documentDefaultNamespace; keySer.SetNamespaceToOverrideEmptyNamespace(keyAlias.Namespace); } key = keySer.DeserializeBase(childElem.Element(keyAlias)); m_parsingErrors.AddRange(keySer.ParsingErrors); } } if (isValueFound) { if (isValueAttrib) { value = ReflectionUtils.ConvertBasicType(childElem.Attribute_NamespaceSafe(valueAlias, m_documentDefaultNamespace).Value, valueType); } else if (isValueContent) { value = ReflectionUtils.ConvertBasicType(childElem.GetXmlContent(), valueType); } else if (ReflectionUtils.IsBasicType(valueType)) { value = ReflectionUtils.ConvertBasicType(childElem.Element(valueAlias).Value, valueType); } else { if (valueSer == null) { valueSer = new YAXSerializer(valueType, m_exceptionPolicy, m_defaultExceptionType, m_serializationOption); valueSer.m_documentDefaultNamespace = m_documentDefaultNamespace; valueSer.SetNamespaceToOverrideEmptyNamespace(valueAlias.Namespace); } value = valueSer.DeserializeBase(childElem.Element(valueAlias)); m_parsingErrors.AddRange(valueSer.ParsingErrors); } } try { type.InvokeMember("Add", BindingFlags.InvokeMethod, null, dic, new object[] { key, value }); } catch { OnExceptionOccurred( new YAXCannotAddObjectToCollection(alias.LocalName, new KeyValuePair<object, object>(key, value)), m_defaultExceptionType); } } return dic; }
/// <summary> /// Creates a dictionary element according to the specified options, as described /// by the attribute instances. /// </summary> /// <param name="insertionLocation">The insertion location.</param> /// <param name="elementName">Name of the element.</param> /// <param name="elementValue">The element value, corresponding to a dictionary object.</param> /// <param name="dicAttrInst">reference to the dictionary attribute instance.</param> /// <param name="collectionAttrInst">reference to collection attribute instance.</param> /// <returns> /// an instance of <c>XElement</c> which contains the dictionary object /// serialized properly /// </returns> private XElement MakeDictionaryElement( XElement insertionLocation, XName elementName, object elementValue, YAXDictionaryAttribute dicAttrInst, YAXCollectionAttribute collectionAttrInst) { if (elementValue == null) { return new XElement(elementName); } Type keyType, valueType; if (!ReflectionUtils.IsIDictionary(elementValue.GetType(), out keyType, out valueType)) { throw new ArgumentException("elementValue must be a Dictionary"); } // serialize other non-collection members var ser = new YAXSerializer(elementValue.GetType(), m_exceptionPolicy, m_defaultExceptionType, m_serializationOption); ser.m_documentDefaultNamespace = m_documentDefaultNamespace; ser.SetNamespaceToOverrideEmptyNamespace(elementName.Namespace); ser.SetBaseElement(insertionLocation); XElement elem = ser.SerializeBase(elementValue, elementName); ImportNamespaces(ser); m_parsingErrors.AddRange(ser.ParsingErrors); // now iterate through collection members var dicInst = elementValue as IEnumerable; bool isKeyAttrib = false; bool isValueAttrib = false; bool isKeyContent = false; bool isValueContent = false; string keyFormat = null; string valueFormat = null; XName keyAlias = elementName.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone() + "Key"; XName valueAlias = elementName.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone() + "Value"; XName eachElementName = null; if (collectionAttrInst != null && !String.IsNullOrEmpty(collectionAttrInst.EachElementName)) { eachElementName = StringUtils.RefineSingleElement(collectionAttrInst.EachElementName); if (eachElementName.Namespace.IsEmpty()) RegisterNamespace(eachElementName.Namespace, null); eachElementName = eachElementName.OverrideNsIfEmpty(elementName.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); } if (dicAttrInst != null) { if (dicAttrInst.EachPairName != null) { eachElementName = StringUtils.RefineSingleElement(dicAttrInst.EachPairName); if (eachElementName.Namespace.IsEmpty()) RegisterNamespace(eachElementName.Namespace, null); eachElementName = eachElementName.OverrideNsIfEmpty(elementName.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); } if (dicAttrInst.SerializeKeyAs == YAXNodeTypes.Attribute) { isKeyAttrib = ReflectionUtils.IsBasicType(keyType); } else if (dicAttrInst.SerializeKeyAs == YAXNodeTypes.Content) { isKeyContent = ReflectionUtils.IsBasicType(keyType); } if (dicAttrInst.SerializeValueAs == YAXNodeTypes.Attribute) { isValueAttrib = ReflectionUtils.IsBasicType(valueType); } else if (dicAttrInst.SerializeValueAs == YAXNodeTypes.Content) { isValueContent = ReflectionUtils.IsBasicType(valueType); } keyFormat = dicAttrInst.KeyFormatString; valueFormat = dicAttrInst.ValueFormatString; keyAlias = StringUtils.RefineSingleElement(dicAttrInst.KeyName ?? "Key"); if (keyAlias.Namespace.IsEmpty()) RegisterNamespace(keyAlias.Namespace, null); keyAlias = keyAlias.OverrideNsIfEmpty(elementName.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); valueAlias = StringUtils.RefineSingleElement(dicAttrInst.ValueName ?? "Value"); if (valueAlias.Namespace.IsEmpty()) RegisterNamespace(valueAlias.Namespace, null); valueAlias = valueAlias.OverrideNsIfEmpty(elementName.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); } foreach (object obj in dicInst) { object keyObj = obj.GetType().GetProperty("Key").GetValue(obj, null); object valueObj = obj.GetType().GetProperty("Value").GetValue(obj, null); bool areKeyOfSameType = true; bool areValueOfSameType = true; if (keyObj != null && !keyObj.GetType().EqualsOrIsNullableOf(keyType)) areKeyOfSameType = false; if (valueObj != null && !valueObj.GetType().EqualsOrIsNullableOf(valueType)) areValueOfSameType = false; if (keyFormat != null) { keyObj = ReflectionUtils.TryFormatObject(keyObj, keyFormat); } if (valueFormat != null) { valueObj = ReflectionUtils.TryFormatObject(valueObj, valueFormat); } if (eachElementName == null) { eachElementName = StringUtils.RefineSingleElement(ReflectionUtils.GetTypeFriendlyName(obj.GetType())); eachElementName = eachElementName.OverrideNsIfEmpty(elementName.Namespace.IfEmptyThen(TypeNamespace).IfEmptyThenNone()); } var elemChild = new XElement(eachElementName, null); if (isKeyAttrib && areKeyOfSameType) { elemChild.AddAttributeNamespaceSafe(keyAlias, keyObj, m_documentDefaultNamespace); } else if (isKeyContent && areKeyOfSameType) { elemChild.AddXmlContent(keyObj); } else { XElement addedElem = AddObjectToElement(elemChild, keyAlias, keyObj); if (!areKeyOfSameType) { if (addedElem.Parent == null) { // sometimes empty elements are removed because its members are serialized in // other elements, therefore we need to make sure to re-add the element. elemChild.Add(addedElem); } addedElem.AddAttributeNamespaceSafe(m_yaxLibNamespaceUri + m_trueTypeAttrName, keyObj.GetType().FullName, m_documentDefaultNamespace); RegisterYaxLibNamespace(); } } if (isValueAttrib && areValueOfSameType) { elemChild.AddAttributeNamespaceSafe(valueAlias, valueObj, m_documentDefaultNamespace); } else if (isValueContent && areValueOfSameType) { elemChild.AddXmlContent(valueObj); } else { XElement addedElem = AddObjectToElement(elemChild, valueAlias, valueObj); if (!areValueOfSameType) { if (addedElem.Parent == null) { // sometimes empty elements are removed because its members are serialized in // other elements, therefore we need to make sure to re-add the element. elemChild.Add(addedElem); } addedElem.AddAttributeNamespaceSafe(m_yaxLibNamespaceUri + m_trueTypeAttrName, valueObj.GetType().FullName, m_documentDefaultNamespace); RegisterYaxLibNamespace(); } } elem.Add(elemChild); } return elem; }
/// <summary> /// Initializes a new instance of the <see cref="MemberWrapper"/> class. /// </summary> /// <param name="memberInfo">The member-info to build this instance from.</param> /// <param name="callerSerializer">The caller serializer.</param> public MemberWrapper(MemberInfo memberInfo, YAXSerializer callerSerializer) { if (!(memberInfo.MemberType == MemberTypes.Property || memberInfo.MemberType == MemberTypes.Field)) throw new Exception("Member must be either property or field"); m_memberInfo = memberInfo; m_isProperty = (memberInfo.MemberType == MemberTypes.Property); Alias = StringUtils.RefineSingleElement(m_memberInfo.Name); if (m_isProperty) m_propertyInfoInstance = (PropertyInfo)memberInfo; else m_fieldInfoInstance = (FieldInfo)memberInfo; m_memberType = m_isProperty ? m_propertyInfoInstance.PropertyType : m_fieldInfoInstance.FieldType; m_memberTypeWrapper = TypeWrappersPool.Pool.GetTypeWrapper(MemberType, callerSerializer); if (m_memberTypeWrapper.HasNamespace) { Namespace = m_memberTypeWrapper.Namespace; NamespacePrefix = m_memberTypeWrapper.NamespacePrefix; } InitInstance(); TreatErrorsAs = callerSerializer != null ? callerSerializer.DefaultExceptionType : YAXExceptionTypes.Error; // discovver YAXCustomSerializerAttributes earlier, because some other attributes depend on it var attrsToProcessEarlier = new HashSet<Type> {typeof (YAXCustomSerializerAttribute), typeof (YAXCollectionAttribute)}; foreach (var attrType in attrsToProcessEarlier) { var customSerAttrs = m_memberInfo.GetCustomAttributes(attrType, true); foreach (var attr in customSerAttrs) { ProcessYaxAttribute(attr); } } foreach (var attr in m_memberInfo.GetCustomAttributes(true)) { // no need to preces, it has been proccessed earlier if (attrsToProcessEarlier.Contains(attr.GetType())) continue; if (attr is YAXBaseAttribute) ProcessYaxAttribute(attr); } // now override some values from memeber-type-wrapper into member-wrapper // if member-type has collection attributes while the member itself does not have them, // then use those of the member-type if (m_collectionAttributeInstance == null && m_memberTypeWrapper.CollectionAttributeInstance != null) m_collectionAttributeInstance = m_memberTypeWrapper.CollectionAttributeInstance; if (m_dictionaryAttributeInstance == null && m_memberTypeWrapper.DictionaryAttributeInstance != null) m_dictionaryAttributeInstance = m_memberTypeWrapper.DictionaryAttributeInstance; }
/// <summary> /// Processes the specified attribute. /// </summary> /// <param name="attr">The attribute to process.</param> private void ProcessYAXAttribute(object attr) { if (attr is YAXCommentAttribute) { string comment = (attr as YAXCommentAttribute).Comment; if(!String.IsNullOrEmpty(comment)) { string[] comments = comment.Split(new [] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); for(int i = 0; i < comments.Length; i++) { comments[i] = String.Format(" {0} ", comments[i].Trim()); } this.Comment = comments; } } else if (attr is YAXSerializableTypeAttribute) { var theAttr = attr as YAXSerializableTypeAttribute; this.FieldsToSerialize = theAttr.FieldsToSerialize; if (theAttr.IsSerializationOptionSet()) { SerializationOption = theAttr.Options; m_isSerializationOptionSetByAttribute = true; } } else if (attr is YAXSerializeAsAttribute) { Alias = StringUtils.RefineSingleElement((attr as YAXSerializeAsAttribute).SerializeAs); } else if (attr is YAXNotCollectionAttribute) { if(!ReflectionUtils.IsArray(m_udtType)) IsAttributedAsNotCollection = true; } else if (attr is YAXCustomSerializerAttribute) { Type serType = (attr as YAXCustomSerializerAttribute).CustomSerializerType; Type genTypeArg; bool isDesiredInterface = ReflectionUtils.IsDerivedFromGenericInterfaceType(serType, typeof(ICustomSerializer<>), out genTypeArg); if (!isDesiredInterface) { throw new YAXException("The provided custom serialization type is not derived from the proper interface"); } if (genTypeArg != UnderlyingType) { throw new YAXException("The generic argument of the class and the type of the class do not match"); } this.CustomSerializerType = serType; } else if(attr is YAXPreserveWhitespaceAttribute) { PreservesWhitespace = true; } else if (attr is YAXNamespaceAttribute) { var nsAttrib = (attr as YAXNamespaceAttribute); Namespace = nsAttrib.Namespace; NamespacePrefix = nsAttrib.Prefix; } else if (attr is YAXCollectionAttribute) { m_collectionAttributeInstance = attr as YAXCollectionAttribute; } else if (attr is YAXDictionaryAttribute) { m_dictionaryAttributeInstance = attr as YAXDictionaryAttribute; } else { throw new Exception("Attribute not applicable to types!"); } }
/// <summary> /// Processes the specified attribute which is an instance of <c>YAXAttribute</c>. /// </summary> /// <param name="attr">The attribute to process.</param> private void ProcessYaxAttribute(object attr) { if (attr is YAXCommentAttribute) { string comment = (attr as YAXCommentAttribute).Comment; if (!String.IsNullOrEmpty(comment)) { string[] comments = comment.Split(new [] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < comments.Length; i++) { comments[i] = String.Format(" {0} ", comments[i].Trim()); } this.Comment = comments; } } else if (attr is YAXSerializableFieldAttribute) { IsAttributedAsSerializable = true; } else if (attr is YAXAttributeForClassAttribute) { // it is required that YAXCustomSerializerAttribute is processed earlier if (ReflectionUtils.IsBasicType(MemberType) || CustomSerializerType != null || (m_collectionAttributeInstance != null && m_collectionAttributeInstance.SerializationType == YAXCollectionSerializationTypes.Serially)) { IsSerializedAsAttribute = true; SerializationLocation = "."; } } else if (attr is YAXValueForClassAttribute) { // it is required that YAXCustomSerializerAttribute is processed earlier if (ReflectionUtils.IsBasicType(MemberType) || CustomSerializerType != null || (m_collectionAttributeInstance != null && m_collectionAttributeInstance.SerializationType == YAXCollectionSerializationTypes.Serially)) { IsSerializedAsValue = true; SerializationLocation = "."; } } else if (attr is YAXAttributeForAttribute) { // it is required that YAXCustomSerializerAttribute is processed earlier if (ReflectionUtils.IsBasicType(MemberType) || CustomSerializerType != null || (m_collectionAttributeInstance != null && m_collectionAttributeInstance.SerializationType == YAXCollectionSerializationTypes.Serially)) { IsSerializedAsAttribute = true; string path, alias; StringUtils.ExttractPathAndAliasFromLocationString((attr as YAXAttributeForAttribute).Parent, out path, out alias); SerializationLocation = path; if (!String.IsNullOrEmpty(alias)) Alias = StringUtils.RefineSingleElement(alias); } } else if (attr is YAXElementForAttribute) { IsSerializedAsElement = true; string path, alias; StringUtils.ExttractPathAndAliasFromLocationString((attr as YAXElementForAttribute).Parent, out path, out alias); SerializationLocation = path; if (!String.IsNullOrEmpty(alias)) Alias = StringUtils.RefineSingleElement(alias); } else if (attr is YAXValueForAttribute) { // it is required that YAXCustomSerializerAttribute is processed earlier if (ReflectionUtils.IsBasicType(this.MemberType) || CustomSerializerType != null || (m_collectionAttributeInstance != null && m_collectionAttributeInstance.SerializationType == YAXCollectionSerializationTypes.Serially)) { IsSerializedAsValue = true; string path, alias; StringUtils.ExttractPathAndAliasFromLocationString((attr as YAXValueForAttribute).Parent, out path, out alias); SerializationLocation = path; if (!String.IsNullOrEmpty(alias)) Alias = StringUtils.RefineSingleElement(alias); } } else if (attr is YAXDontSerializeAttribute) { IsAttributedAsDontSerialize = true; } else if (attr is YAXSerializeAsAttribute) { Alias = StringUtils.RefineSingleElement((attr as YAXSerializeAsAttribute).SerializeAs); } else if (attr is YAXCollectionAttribute) { m_collectionAttributeInstance = attr as YAXCollectionAttribute; } else if (attr is YAXDictionaryAttribute) { m_dictionaryAttributeInstance = attr as YAXDictionaryAttribute; } else if (attr is YAXErrorIfMissedAttribute) { var temp = attr as YAXErrorIfMissedAttribute; DefaultValue = temp.DefaultValue; TreatErrorsAs = temp.TreatAs; } else if (attr is YAXFormatAttribute) { Format = (attr as YAXFormatAttribute).Format; } else if (attr is YAXNotCollectionAttribute) { // arrays are always treated as collections if (!ReflectionUtils.IsArray(MemberType)) IsAttributedAsNotCollection = true; } else if (attr is YAXCustomSerializerAttribute) { Type serType = (attr as YAXCustomSerializerAttribute).CustomSerializerType; Type genTypeArg; bool isDesiredInterface = ReflectionUtils.IsDerivedFromGenericInterfaceType(serType, typeof(ICustomSerializer<>), out genTypeArg); if (!isDesiredInterface) { throw new YAXException("The provided custom serialization type is not derived from the proper interface"); } else if (genTypeArg != this.MemberType) { throw new YAXException("The generic argument of the class and the member type do not match"); } else { CustomSerializerType = serType; } } else if(attr is YAXPreserveWhitespaceAttribute) { PreservesWhitespace = true; } else if (attr is YAXSerializableTypeAttribute) { // this should not happen throw new Exception("This attribute is not applicable to fields and properties!"); } else if (attr is YAXNamespaceAttribute) { var nsAttrib = (attr as YAXNamespaceAttribute); Namespace = nsAttrib.Namespace; NamespacePrefix = nsAttrib.Prefix; } else { throw new Exception("Added new attribute type to the library but not yet processed!"); } }