public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { var isNil = reader.IsNil(); if (isNil && reader.IsEmptyElement) { return(null); } object deserializedObject; var type = reader.GetXsdType <object>(_options.ExtraTypes); if (type != null) { var serializer = XmlSerializerFactory.Instance.GetSerializer(type, _encryptAttribute, _options.WithRootElementName(reader.Name)); deserializedObject = serializer.DeserializeObject(reader, options); } else { deserializedObject = DeserializeToDynamic(reader, options); } return (isNil ? null : deserializedObject); }
public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { if (ValueTypes.IsRegistered(typeof(T))) { while (reader.NodeType != XmlNodeType.Element) { reader.Read(); } } if (reader.IsNil()) { return(default(T)); } var setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); var value = reader.ReadString(); if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return(_valueConverter.ParseString(value, options)); }
private static object DeserializeKeyOrValue(XSerializerXmlReader reader, IXmlSerializerInternal serializer, ISerializeOptions options, out bool shouldIssueRead) { var deserialized = serializer.DeserializeObject(reader, options); shouldIssueRead = true; return(deserialized); }
private void SetElementPropertyValue(XSerializerXmlReader reader, bool hasInstanceBeenCreated, ISerializeOptions options, IDictionary <string, object> expando) { var propertyName = reader.Name; var serializer = DynamicSerializer.GetSerializer <object>(null, _options.WithRootElementName(reader.Name)); var value = serializer.DeserializeObject(reader, options); expando[propertyName] = value; }
public static object DeserializeObject(this IXmlSerializerInternal serializer, TextReader textReader, ISerializeOptions options) { options = options.WithNewSerializationState(); var xmlReader = new XmlTextReader(textReader); var reader = new XSerializerXmlReader(xmlReader, options.GetEncryptionMechanism(), options.EncryptKey, options.SerializationState); return(serializer.DeserializeObject(reader, options)); }
internal static bool ReadIfNeeded(this XSerializerXmlReader reader, bool shouldRead) { if (shouldRead) { return(reader.Read()); } return(true); }
/// <summary> /// Maybe sets the <see cref="XSerializerXmlTextWriter.IsEncryptionEnabled"/> property of /// <paramref name="reader"/> to true. Returns true if the value was changed to true, false /// if it was not changed to true. /// </summary> internal static bool MaybeSetIsDecryptionEnabledToTrue(this XSerializerXmlReader reader, EncryptAttribute encryptAttribute, ISerializeOptions options) { if (options.ShouldEncrypt && encryptAttribute != null && !reader.IsDecryptionEnabled) { reader.IsDecryptionEnabled = true; return(true); } return(false); }
public DefaultConstructorHelper( Func <T> createInstance, Dictionary <string, SerializableProperty> caseSensitiveSerializableProperties, SerializableProperty textNodeProperty, IDictionary <string, SerializableProperty> attributeProperties, XSerializerXmlReader reader) { _reader = reader; _caseSensitiveSerializableProperties = caseSensitiveSerializableProperties; _textNodeProperty = textNodeProperty; _attributeProperties = attributeProperties; _instance = createInstance(); }
public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { var setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); var value = _valueConverter.ParseString(reader.Value, options); if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return value; }
private static object DeserializeItem(XSerializerXmlReader reader, IXmlSerializerInternal serializer, bool hasInstanceBeenCreated, ISerializeOptions options, out bool shouldIssueRead) { if (!hasInstanceBeenCreated) { throw new InvalidOperationException("Deserialization error: attempted to deserialize an item before creating its list."); } var deserialized = serializer.DeserializeObject(reader, options); shouldIssueRead = true; return(deserialized); }
public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { var setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); var value = _valueConverter.ParseString(reader.Value, options); if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return(value); }
public NonDefaultConstructorHelper( IEnumerable <ConstructorWrapper> constructors, IEnumerable <SerializableProperty> serializableProperties, SerializableProperty textNodeProperty, IDictionary <string, SerializableProperty> attributeProperties, IDictionary <string, SerializableProperty> caseSensitiveSerializableProperties, XSerializerXmlReader reader) { _constructors = constructors; _serializableProperties = serializableProperties; _textNodeProperty = textNodeProperty; _attributeProperties = attributeProperties; _caseSensitiveSerializableProperties = caseSensitiveSerializableProperties; _reader = reader; }
public static object DeserializeObject(this IXmlSerializerInternal serializer, string xml, ISerializeOptions options) { options = options.WithNewSerializationState(); using (var stringReader = new StringReader(xml)) { using (var xmlReader = new XmlTextReader(stringReader)) { using (var reader = new XSerializerXmlReader(xmlReader, options.GetEncryptionMechanism(), options.EncryptKey, options.SerializationState)) { return(serializer.DeserializeObject(reader, options)); } } } }
public override bool Read() { if (_surrogateReader != null) { if (_surrogateReader.Read() && !IsAtDummyNodeEndElement()) { // If this isn't the closing dummy node, return true. return(true); } // When we're done with surrogateReader, get rid of it and go back to primaryReader. _surrogateReader.Close(); _surrogateReader = null; _currentReader = _primaryReader; } var read = _primaryReader.Read(); if (!read) { return(false); } // If we're decrypting, and our node contains text that starts with '<', then // assume that the text contains one or more encrypted child elements. In this // case, load the decrypted contents into a surrogate xml reader and use that // reader until it reads to its end. Then switch back to the primary reader. if (IsDecryptionEnabled && NodeType == XmlNodeType.Text) { var value = Value; if (_isStartElementRegex.IsMatch(value)) { // The xml fragment contained in the Value property may contain multiple // top-level elements. To ensure valid xml, wrap the fragment in a dummy node. var xml = _dummyNodeStartElement + value + _dummyNodeEndElement; _surrogateReader = new XSerializerXmlReader(xml, _encryptionMechanism, _encryptKey, _serializationState); _currentReader = _surrogateReader; _surrogateReader.Read(); // Advance to the opening dummy node return(_surrogateReader.Read()); // Advance to the first decrypted node. } } return(true); }
public override bool Read() { if (_surrogateReader != null) { if (_surrogateReader.Read() && !IsAtDummyNodeEndElement()) { // If this isn't the closing dummy node, return true. return true; } // When we're done with surrogateReader, get rid of it and go back to primaryReader. _surrogateReader.Close(); _surrogateReader = null; _currentReader = _primaryReader; } var read = _primaryReader.Read(); if (!read) { return false; } // If we're decrypting, and our node contains text that starts with '<', then // assume that the text contains one or more encrypted child elements. In this // case, load the decrypted contents into a surrogate xml reader and use that // reader until it reads to its end. Then switch back to the primary reader. if (IsDecryptionEnabled && NodeType == XmlNodeType.Text) { var value = Value; if (_isStartElementRegex.IsMatch(value)) { // The xml fragment contained in the Value property may contain multiple // top-level elements. To ensure valid xml, wrap the fragment in a dummy node. var xml = _dummyNodeStartElement + value + _dummyNodeEndElement; _surrogateReader = new XSerializerXmlReader(xml, _encryptionMechanism, _encryptKey, _serializationState); _currentReader = _surrogateReader; _surrogateReader.Read(); // Advance to the opening dummy node return _surrogateReader.Read(); // Advance to the first decrypted node. } } return true; }
public IHelper CreateHelper(Type type, XSerializerXmlReader reader) { var temp = type; Lazy <Func <XSerializerXmlReader, IHelper> > createHelper; while (!_createHelperFuncs.TryGetValue(temp, out createHelper)) { temp = temp.BaseType; if (temp == null) { throw new InvalidOperationException("Unable to find serializable properties for type " + type); } } return(createHelper.Value(reader)); }
internal static bool IsNil(this XSerializerXmlReader reader) { var nilFound = false; while (reader.MoveToNextAttribute()) { if (reader.LocalName == "nil" && reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema-instance") { nilFound = true; break; } } reader.MoveToElement(); return(nilFound); }
private static object DeserializeItem(XSerializerXmlReader reader, IXmlSerializerInternal serializer, bool hasInstanceBeenCreated, ISerializeOptions options, out bool shouldIssueRead) { if (!hasInstanceBeenCreated) { throw new InvalidOperationException("Deserialization error: attempted to deserialize an item before creating its list."); } var deserialized = serializer.DeserializeObject(reader, options); shouldIssueRead = true; return deserialized; }
public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { return((ExpandoObject)_serializer.DeserializeToDynamic(reader, options)); }
private static object DeserializeKeyOrValue(XSerializerXmlReader reader, IXmlSerializerInternal serializer, ISerializeOptions options, out bool shouldIssueRead) { var deserialized = serializer.DeserializeObject(reader, options); shouldIssueRead = true; return deserialized; }
private dynamic DeserializeToDynamic(XSerializerXmlReader reader, ISerializeOptions options) { object instance = null; var hasInstanceBeenCreated = false; var setIsDecryptionEnabledBackToFalse = false; Func <bool> isAtRootElement; { var hasOpenedRootElement = false; isAtRootElement = () => { if (!hasOpenedRootElement && reader.Name == _options.RootElementName) { hasOpenedRootElement = true; return(true); } return(false); }; } do { switch (reader.NodeType) { case XmlNodeType.Element: if (isAtRootElement()) { setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); instance = new ExpandoObject(); hasInstanceBeenCreated = true; if (reader.IsEmptyElement) { if (_options.TreatEmptyElementAsString) { instance = ""; } if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return(instance); } } else { SetElementPropertyValue(reader, hasInstanceBeenCreated, options, (ExpandoObject)instance); } break; case XmlNodeType.Text: var stringValue = (string)new XmlTextSerializer(typeof(string), _options.RedactAttribute, null, _options.ExtraTypes).DeserializeObject(reader, options); hasInstanceBeenCreated = true; bool boolValue; if (bool.TryParse(stringValue, out boolValue)) { instance = boolValue; break; } int intValue; if (int.TryParse(stringValue, out intValue)) { // If this is a number with leading zeros, treat it as a string so we don't lose those leading zeros. if (stringValue[0] == '0' && stringValue.Length > 1) { instance = stringValue; } else { instance = intValue; } break; } decimal decimalValue; if (decimal.TryParse(stringValue, out decimalValue)) { instance = decimalValue; break; } DateTime dateTimeValue; if (DateTime.TryParse(stringValue, out dateTimeValue)) { instance = dateTimeValue.ToUniversalTime(); break; } // TODO: add more types to check? instance = stringValue; break; case XmlNodeType.EndElement: if (reader.Name == _options.RootElementName) { if (_options.TreatEmptyElementAsString) { var instanceAsExpando = instance as IDictionary <string, object>; if (instanceAsExpando != null && instanceAsExpando.Count == 0) { instance = ""; } } if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return(CheckAndReturn(hasInstanceBeenCreated, instance)); } break; } } while (reader.Read()); throw new InvalidOperationException("Deserialization error: reached the end of the document without returning a value."); }
public void ReadValue(XSerializerXmlReader reader, object instance, ISerializeOptions options) { SetValue(instance, ReadValue(reader, options)); }
public object ReadValue(XSerializerXmlReader reader, ISerializeOptions options) { return(_serializer.Value.DeserializeObject(reader, options)); }
public IHelper CreateHelper(Type type, XSerializerXmlReader reader) { var temp = type; Lazy<Func<XSerializerXmlReader, IHelper>> createHelper; while (!_createHelperFuncs.TryGetValue(temp, out createHelper)) { temp = temp.BaseType; if (temp == null) { throw new InvalidOperationException("Unable to find serializable properties for type " + type); } } return createHelper.Value(reader); }
public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { object dictionary = null; var hasInstanceBeenCreated = false; var isInsideItemElement = false; object currentKey = null; object currentValue = null; bool shouldIssueRead; var setIsDecryptionEnabledBackToFalse = false; Func <bool> isAtRootElement; { var hasOpenedRootElement = false; isAtRootElement = () => { if (!hasOpenedRootElement && reader.Name == _options.RootElementName) { hasOpenedRootElement = true; return(true); } return(false); }; } do { shouldIssueRead = true; switch (reader.NodeType) { case XmlNodeType.Element: if (isAtRootElement()) { if (reader.IsNil()) { if (reader.IsEmptyElement) { return(null); } dictionary = null; hasInstanceBeenCreated = true; } else { setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); dictionary = _createDictionary(); hasInstanceBeenCreated = true; if (reader.IsEmptyElement) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return(_finalizeDictionary(dictionary)); } } } else if (reader.Name == "Item" && hasInstanceBeenCreated) { isInsideItemElement = true; } else if (isInsideItemElement) { if (reader.Name == "Key") { currentKey = DeserializeKeyOrValue(reader, _keySerializer, options, out shouldIssueRead); } else if (reader.Name == "Value") { currentValue = DeserializeKeyOrValue(reader, _valueSerializer, options, out shouldIssueRead); } } break; case XmlNodeType.EndElement: if (isInsideItemElement && reader.Name == "Item") { AddItemToDictionary(dictionary, currentKey, currentValue); currentKey = null; currentValue = null; isInsideItemElement = false; } else if (reader.Name == _options.RootElementName) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return(CheckAndReturn(hasInstanceBeenCreated, _finalizeDictionary(dictionary))); } break; } } while (reader.ReadIfNeeded(shouldIssueRead)); throw new InvalidOperationException("Deserialization error: reached the end of the document without returning a value."); }
public static Type GetXsdType <T>(this XSerializerXmlReader reader, Type[] extraTypes) { string typeName = null; while (reader.MoveToNextAttribute()) { if (reader.LocalName == "type" && reader.LookupNamespace(reader.Prefix) == "http://www.w3.org/2001/XMLSchema-instance") { typeName = reader.Value; break; } } reader.MoveToElement(); if (typeName == null) { return(null); } Type typeFromXsdType; if (_xsdTypeToTypeMap.TryGetValue(typeName, out typeFromXsdType)) { return(typeFromXsdType); } return(_xsdTypeToTypeCache.GetOrAdd( Tuple.Create(typeof(T), typeName), _ => { Type type = null; //// try REAL hard to get the type. (holy crap, this is UUUUUGLY!!!!) if (extraTypes != null) { var matchingExtraTypes = extraTypes.Where(t => t.Name == typeName && typeof(T).IsAssignableFrom(t)).ToList(); if (matchingExtraTypes.Count == 1) { type = matchingExtraTypes[0]; } } if (type == null) { var typeNameWithPossibleNamespace = typeName; if (!typeName.Contains('.')) { typeNameWithPossibleNamespace = typeof(T).Namespace + "." + typeName; } var checkPossibleNamespace = typeName != typeNameWithPossibleNamespace; type = Type.GetType(typeName); type = typeof(T).IsAssignableFrom(type) ? type : null; if (type == null) { type = checkPossibleNamespace ? Type.GetType(typeNameWithPossibleNamespace) : null; type = typeof(T).IsAssignableFrom(type) ? type : null; if (type == null) { type = typeof(T).Assembly.GetType(typeName); type = typeof(T).IsAssignableFrom(type) ? type : null; if (type == null) { type = checkPossibleNamespace ? typeof(T).Assembly.GetType(typeNameWithPossibleNamespace) : null; type = typeof(T).IsAssignableFrom(type) ? type : null; if (type == null) { var matches = typeof(T).Assembly.GetTypes().Where(t => t.Name == typeName && typeof(T).IsAssignableFrom(t)).ToList(); if (matches.Count == 1) { type = matches.Single(); } var entryAssembly = Assembly.GetEntryAssembly(); if (entryAssembly != null) { type = entryAssembly.GetType(typeName); type = typeof(T).IsAssignableFrom(type) ? type : null; if (type == null) { type = checkPossibleNamespace ? entryAssembly.GetType(typeNameWithPossibleNamespace) : null; type = typeof(T).IsAssignableFrom(type) ? type : null; } if (type == null) { matches = entryAssembly.GetTypes().Where(t => t.Name == typeName && typeof(T).IsAssignableFrom(t)).ToList(); if (matches.Count == 1) { type = matches.Single(); } } } if (type == null) { matches = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => { try { return a.GetTypes(); } catch { return Enumerable.Empty <Type>(); } }).Where(t => t.Name == typeName && typeof(T).IsAssignableFrom(t)).ToList(); if (matches.Count == 1) { type = matches.Single(); } else if (matches.Count > 1) { throw new SerializationException(string.Format("More than one type matches '{0}'. Consider decorating your type with the XmlIncludeAttribute, or pass in the type into the serializer as an extra type.", typeName)); } } } } } } } if (type == null) { throw new SerializationException(string.Format("No suitable type matches '{0}'. Consider decorating your type with the XmlIncludeAttribute, or pass in the type into the serializer as an extra type.", typeName)); } return type; })); }
public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { object collection = null; var hasInstanceBeenCreated = false; bool shouldIssueRead; var setIsDecryptionEnabledBackToFalse = false; if (_options.RootElementName == null) { setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); collection = _createCollection(); hasInstanceBeenCreated = true; } do { shouldIssueRead = true; switch (reader.NodeType) { case XmlNodeType.Element: if (_options.RootElementName != null) { if (reader.Name == _options.RootElementName) { if (reader.IsNil()) { if (reader.IsEmptyElement) { return null; } collection = null; hasInstanceBeenCreated = true; } else { setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); collection = _createCollection(); hasInstanceBeenCreated = true; if (reader.IsEmptyElement) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return collection; } } break; } } else { // If there's no root element, and we encounter another element, we're done - get out! if (reader.Name != _itemElementName) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return collection == null ? null : CheckAndReturn(hasInstanceBeenCreated, collection); } } if (reader.Name == _itemElementName) { var item = DeserializeItem(reader, _itemSerializer, hasInstanceBeenCreated, options, out shouldIssueRead); if (collection != null) { AddItemToCollection(collection, item); } } break; case XmlNodeType.EndElement: if (_options.RootElementName != null) { if (reader.Name == _options.RootElementName) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return collection == null ? null : CheckAndReturn(hasInstanceBeenCreated, collection); } } else { if (reader.Name != _itemElementName) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return collection == null ? null : CheckAndReturn(hasInstanceBeenCreated, collection); } } break; } } while (reader.ReadIfNeeded(shouldIssueRead)); throw new InvalidOperationException("Deserialization error: attempted to return a deserialized instance before it was created."); }
public DefaultConstructorHelper( Func<T> createInstance, Dictionary<string, SerializableProperty> caseSensitiveSerializableProperties, SerializableProperty textNodeProperty, IDictionary<string, SerializableProperty> attributeProperties, XSerializerXmlReader reader) { _reader = reader; _caseSensitiveSerializableProperties = caseSensitiveSerializableProperties; _textNodeProperty = textNodeProperty; _attributeProperties = attributeProperties; _instance = createInstance(); }
public NonDefaultConstructorHelper( IEnumerable<ConstructorWrapper> constructors, IEnumerable<SerializableProperty> serializableProperties, SerializableProperty textNodeProperty, IDictionary<string, SerializableProperty> attributeProperties, IDictionary<string, SerializableProperty> caseSensitiveSerializableProperties, XSerializerXmlReader reader) { _constructors = constructors; _serializableProperties = serializableProperties; _textNodeProperty = textNodeProperty; _attributeProperties = attributeProperties; _caseSensitiveSerializableProperties = caseSensitiveSerializableProperties; _reader = reader; }
public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { object collection = null; var hasInstanceBeenCreated = false; bool shouldIssueRead; var setIsDecryptionEnabledBackToFalse = false; if (_options.RootElementName == null) { setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); collection = _createCollection(); hasInstanceBeenCreated = true; } do { shouldIssueRead = true; switch (reader.NodeType) { case XmlNodeType.Element: if (_options.RootElementName != null) { if (reader.Name == _options.RootElementName) { if (reader.IsNil()) { if (reader.IsEmptyElement) { return(null); } collection = null; hasInstanceBeenCreated = true; } else { setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); collection = _createCollection(); hasInstanceBeenCreated = true; if (reader.IsEmptyElement) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return(collection); } } break; } } else { // If there's no root element, and we encounter another element, we're done - get out! if (reader.Name != _itemElementName) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return (collection == null ? null : CheckAndReturn(hasInstanceBeenCreated, collection)); } } if (reader.Name == _itemElementName) { var item = DeserializeItem(reader, _itemSerializer, hasInstanceBeenCreated, options, out shouldIssueRead); if (collection != null) { AddItemToCollection(collection, item); } } break; case XmlNodeType.EndElement: if (_options.RootElementName != null) { if (reader.Name == _options.RootElementName) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return (collection == null ? null : CheckAndReturn(hasInstanceBeenCreated, collection)); } } else { if (reader.Name != _itemElementName) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return (collection == null ? null : CheckAndReturn(hasInstanceBeenCreated, collection)); } } break; } } while (reader.ReadIfNeeded(shouldIssueRead)); throw new InvalidOperationException("Deserialization error: attempted to return a deserialized instance before it was created."); }
public object DeserializeObject(XSerializerXmlReader reader, ISerializeOptions options) { object dictionary = null; var hasInstanceBeenCreated = false; var isInsideItemElement = false; object currentKey = null; object currentValue = null; bool shouldIssueRead; var setIsDecryptionEnabledBackToFalse = false; Func<bool> isAtRootElement; { var hasOpenedRootElement = false; isAtRootElement = () => { if (!hasOpenedRootElement && reader.Name == _options.RootElementName) { hasOpenedRootElement = true; return true; } return false; }; } do { shouldIssueRead = true; switch (reader.NodeType) { case XmlNodeType.Element: if (isAtRootElement()) { if (reader.IsNil()) { if (reader.IsEmptyElement) { return null; } dictionary = null; hasInstanceBeenCreated = true; } else { setIsDecryptionEnabledBackToFalse = reader.MaybeSetIsDecryptionEnabledToTrue(_encryptAttribute, options); dictionary = _createDictionary(); hasInstanceBeenCreated = true; if (reader.IsEmptyElement) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return _finalizeDictionary(dictionary); } } } else if (reader.Name == "Item" && hasInstanceBeenCreated) { isInsideItemElement = true; } else if (isInsideItemElement) { if (reader.Name == "Key") { currentKey = DeserializeKeyOrValue(reader, _keySerializer, options, out shouldIssueRead); } else if (reader.Name == "Value") { currentValue = DeserializeKeyOrValue(reader, _valueSerializer, options, out shouldIssueRead); } } break; case XmlNodeType.EndElement: if (isInsideItemElement && reader.Name == "Item") { AddItemToDictionary(dictionary, currentKey, currentValue); currentKey = null; currentValue = null; isInsideItemElement = false; } else if (reader.Name == _options.RootElementName) { if (setIsDecryptionEnabledBackToFalse) { reader.IsDecryptionEnabled = false; } return CheckAndReturn(hasInstanceBeenCreated, _finalizeDictionary(dictionary)); } break; } } while (reader.ReadIfNeeded(shouldIssueRead)); throw new InvalidOperationException("Deserialization error: reached the end of the document without returning a value."); }