/// <summary> /// Initializes a new instance of the System.Runtime.Serialization.DataContractSerializer /// class to serialize or deserialize an object of the specified type. /// </summary> /// <param name="type">The type of the instances that are serialized or deserialized.</param> /// <param name="useXmlSerializerFormat"></param> public DataContractSerializer(Type type, bool useXmlSerializerFormat = false) { DataContractSerializer_ValueTypesHandler.EnsureInitialized(); _type = type; _useXmlSerializerFormat = useXmlSerializerFormat; }
static object DeserializeToCSharpObject_ValueTypeOrString(IEnumerable <XNode> content, Type resultType) { if (content.Any()) { foreach (XNode node in content) { if (node is XText) // Normally value types were serialized as direct text content { XText text = (XText)node; string str = text.Value; return(DataContractSerializer_ValueTypesHandler.ConvertStringToValueType(str, resultType)); } } } else { //------------------------- // We have arrived to an empty node, such as in: <MyObject><MyStringProperty /></MyObject> //------------------------- if (resultType == typeof(string)) { return(string.Empty); } } throw new Exception("Unable to create the type '" + resultType.ToString() + "'."); }
/// <summary> /// Initializes a new instance of the System.Runtime.Serialization.DataContractSerializer /// class to serialize or deserialize an object of the specified type, and a /// collection of known types that may be present in the object graph. /// </summary> /// <param name="type">The type of the instances that are serialized or deserialized.</param> /// <param name="knownTypes"> /// An System.Collections.Generic.IEnumerable`1 of System.Type that contains /// the types that may be present in the object graph. /// </param> /// <param name="useXmlSerializerFormat"></param> public DataContractSerializer(Type type, IEnumerable <Type> knownTypes, bool useXmlSerializerFormat = false) { DataContractSerializer_ValueTypesHandler.EnsureInitialized(); _type = type; _useXmlSerializerFormat = useXmlSerializerFormat; if (knownTypes != null) { ((List <Type>)_knownTypes).AddRange(knownTypes); } }
/// <summary> /// Initializes a new instance of the System.Runtime.Serialization.DataContractSerializer /// class to serialize or deserialize an object of the specified type, and a /// collection of known types that may be present in the object graph. /// </summary> /// <param name="type">The type of the instances that are serialized or deserialized.</param> /// <param name="knownTypes"> /// An System.Collections.Generic.IEnumerable`1 of System.Type that contains /// the types that may be present in the object graph. /// </param> /// <param name="useXmlSerializerFormat"></param> public DataContractSerializer(Type type, IEnumerable <Type> knownTypes, bool useXmlSerializerFormat = false) { DataContractSerializer_ValueTypesHandler.EnsureInitialized(); _type = type; _useXmlSerializerFormat = useXmlSerializerFormat; if (knownTypes != null) { ((List <Type>)_knownTypes).AddRange(knownTypes); } if (KnownTypesHelper._additionalKnownTypes != null) { ((List <Type>)_knownTypes).AddRange(KnownTypesHelper._additionalKnownTypes); //todo: add only the items that are not already in the destination collection? } }
static object DeserializeToCSharpObject_Object_WithRecursion(IEnumerable <XNode> content, Type resultType, XElement parentElement, IReadOnlyList <Type> knownTypes, bool ignoreErrors, bool useXmlSerializerFormat) { // Quit if attempting to deserialize to an interface: //todo: investigate why this may happen. if (!resultType.IsInterface) { string resultTypeFullName = resultType.FullName; // For debugging only, can be removed. // Create the resulting class: object resultInstance = Activator.CreateInstance(resultType); //todo: replace with "System.Runtime.Serialization.FormatterServices.GetUninitializedObject(type)" so that the type does not require a parameterless constructor. // Call the "OnDeserializing" method if any: CallOnDeserializingMethod(resultInstance, resultType); // Get the type information (namespace, etc.) by reading the DataContractAttribute and similar attributes, if present: TypeInformation typeInformation = DataContractSerializer_Helpers.GetTypeInformationByReadingAttributes(resultType, null); // Read the members of the target type: IEnumerable <MemberInformation> membersInformation = DataContractSerializer_Helpers.GetDataContractMembers(resultType, typeInformation.serializationType, useXmlSerializerFormat); // Make a dictionary of the members of the target type for faster lookup: Dictionary <string, MemberInformation> memberNameToMemberInformation = new Dictionary <string, MemberInformation>(); foreach (var memberInformation in membersInformation) { string memberName = memberInformation.Name; if (resultType.FullName.StartsWith("System.Collections.Generic.KeyValuePair")) { if (memberName == "key") { memberName = "Key"; } else if (memberName == "value") { memberName = "Value"; } } if (!memberNameToMemberInformation.ContainsKey(memberName)) { memberNameToMemberInformation.Add(memberName, memberInformation); } else { MemberInformation collidingMemberInformation = memberNameToMemberInformation[memberName]; throw new InvalidDataContractException( string.Format( "Type '{0}' contains two members '{1}' 'and '{2}' with the same data member name '{3}'. Multiple members with the same name in one type are not supported. Consider changing one of the member names using DataMemberAttribute attribute.", resultType.ToString(), memberInformation.MemberInfo.Name, collidingMemberInformation.MemberInfo.Name, memberName )); } } // Populate the values of the properties/members of the class: HashSet2 <string> membersForWhichWeSuccessfullSetTheValue = new HashSet2 <string>(); foreach (XNode node in content) { if (node is XElement) // Normally an object property was serialized as an XElement. { XElement xElement = (XElement)node; XName elementName = xElement.Name; string elementNameWithoutNamespace = elementName.LocalName; // Find the member that has the name of the XNode: MemberInformation memberInformation; if (memberNameToMemberInformation.TryGetValue(elementNameWithoutNamespace, out memberInformation)) { // Avoid processing nodes that have the same name as other nodes already processed (this can happen in case of [XmlElement] attribute on enumerable members - cf. "special case" below - but it is handled differently): if (!membersForWhichWeSuccessfullSetTheValue.Contains(memberInformation.Name)) { object memberValue = null; Type memberActualType = memberInformation.MemberType; // Note: this is the initial value. It may be modified below. if (DataContractSerializer_Helpers.IsElementNil(xElement)) { //---------------------- // XNode is "Nil", so we return the default value of the result type //---------------------- memberValue = DataContractSerializer_Helpers.GetDefault(memberInformation.MemberType); } else { bool isNull = false; //foreach (XAttribute attribute in xElement.Attributes(XNamespace.Get("http://www.w3.org/2001/XMLSchema-instance").GetName("nil"))) //doesn't work... //todo: try removing this foreach since it should be handled in the "if(IsElementDefaut(xElement))" above. foreach (XAttribute attribute in xElement.Attributes("nil")) //We have to do this here because those usually do not have nodes, which causes problems when doing the recursion. { isNull = Convert.ToBoolean(attribute.Value); if (isNull) { memberValue = null; } } if (!isNull) { memberActualType = DataContractSerializer_KnownTypes.GetCSharpTypeForNode(xElement, memberInformation.MemberInfo.DeclaringType, memberActualType, knownTypes, memberInformation); //if the type is nullable, we get the undelying type: Type nonNullableMemberType = memberActualType; if (memberActualType.FullName.StartsWith("System.Nullable`1")) { nonNullableMemberType = Nullable.GetUnderlyingType(memberActualType); } // Recursively create the value for the property: IEnumerable <XNode> propertyChildNodes = xElement.Nodes(); //********** RECURSION ********** memberValue = DeserializeToCSharpObject(propertyChildNodes, nonNullableMemberType, xElement, knownTypes, ignoreErrors, useXmlSerializerFormat); } //--------------------------------- // Handle the special case where there is an [XmlElement] attribute on an enumerable member (XmlSerializer compatibility mode only): // // Example: // <MyObject> // <MyEnumerablePropertyName/> // <MyEnumerablePropertyName/> // <MyEnumerablePropertyName/> // </MyObject> // // obtained via: // class MyObject // { // [XmlElement] // List<MyType> MyEnumerablePropertyName { get; set; } // } // // cf. https://docs.microsoft.com/en-us/dotnet/standard/serialization/controlling-xml-serialization-using-attributes //--------------------------------- Type itemsType = null; bool specialCaseWhereAnEnumerableHasTheXmlElementAttribute = (useXmlSerializerFormat && memberInformation.HasXmlElementAttribute && DataContractSerializer_Helpers.IsAssignableToGenericEnumerableOrArray(memberActualType, out itemsType)); if (specialCaseWhereAnEnumerableHasTheXmlElementAttribute) { object deserializedEnumerable = DeserializeToCSharpObject_Enumerable_WithRecursion_SpecialCase( memberInformation.Name, content, memberActualType, knownTypes, ignoreErrors, itemsType, useXmlSerializerFormat); memberValue = deserializedEnumerable; } //--------------------------------- // Set the value of the member: //--------------------------------- DataContractSerializer_Helpers.SetMemberValue(resultInstance, memberInformation, memberValue); membersForWhichWeSuccessfullSetTheValue.Add(memberInformation.Name); } } } else { //----------- // We ignore missing members, to mimic the behavior of the .NET DataContractSerializer. //----------- //throw new Exception("Member '" + memberName + "' not found in type '" + resultType.Name + "'."); } } } // In case of XmlSerializer compatibility mode, and [XmlAttribute] attribute on a class member, we also need to deserialize the XAttributes (cf. https://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlattributeattribute(v=vs.110).aspx ): if (useXmlSerializerFormat) { foreach (XAttribute attribute in parentElement.Attributes()) { XName attributeName = attribute.Name; // We assume that the object properties have no namespace //todo: fix this assumption, cf. "XmlAttributeAttribute.Namespace" for example (note: repetition of "Attribute" is intended) if (string.IsNullOrEmpty(attributeName.NamespaceName)) { string attributeNameWithoutNamespace = attributeName.LocalName; // Find the member that has the name of the XAttribute: MemberInformation memberInformation; if (memberNameToMemberInformation.TryGetValue(attributeNameWithoutNamespace, out memberInformation) && memberInformation.HasXmlAttributeAttribute) { // Avoid processing members that have already been processed (just in case): if (!membersForWhichWeSuccessfullSetTheValue.Contains(memberInformation.Name)) { string attributeValue = attribute.Value; // Check to see if the expected type is a value type: if (DataContractSerializer_ValueTypesHandler.TypesToNames.ContainsKey(memberInformation.MemberType)) { // Attempt to deserialize the string: object memberValue = DataContractSerializer_ValueTypesHandler.ConvertStringToValueType(attributeValue, memberInformation.MemberType); // Set the value of the member: DataContractSerializer_Helpers.SetMemberValue(resultInstance, memberInformation, memberValue); membersForWhichWeSuccessfullSetTheValue.Add(memberInformation.Name); } else { //todo: report the error? if (memberInformation.MemberType == typeof(List <int>)) { string[] splittedElements = attributeValue.Split(' '); #if !BRIDGE List <int> listint = splittedElements.Select(Int32.Parse).ToList(); #else List <int> listint = new List <int>(); foreach (string str in splittedElements) { listint.Add(Int32.Parse(str)); } #endif DataContractSerializer_Helpers.SetMemberValue(resultInstance, memberInformation, listint); membersForWhichWeSuccessfullSetTheValue.Add(memberInformation.Name); } } } else { //todo: report the error? } } else { //todo: report the error? } } } } // Verify that the values of all the members marked as "IsRequired" have been set: foreach (var memberInformation in membersInformation) { if (memberInformation.IsRequired && !membersForWhichWeSuccessfullSetTheValue.Contains(memberInformation.Name)) { throw new SerializationException(string.Format("The member '{0}' is required but it was not found in the document being deserialized.", memberInformation.Name)); } } // Call the "OnDeserialized" method if any: CallOnDeserializedMethod(resultInstance, resultType); return(resultInstance); } else { return(null); } }