コード例 #1
0
        private static void ReadAttributes(XmlReader reader, XmlConfigurationElement element)
        {
            if (reader.AttributeCount > 0)
            {
                element.Attributes = new List <XmlConfigurationElementAttributeValue>();
            }

            var lineInfo = reader as IXmlLineInfo;

            for (int i = 0; i < reader.AttributeCount; i++)
            {
                reader.MoveToAttribute(i);

                var lineNumber   = lineInfo?.LineNumber;
                var linePosition = lineInfo?.LinePosition;

                // If there is a namespace attached to current attribute
                if (!string.IsNullOrEmpty(reader.NamespaceURI))
                {
                    throw new FormatException(SR.Format(SR.Error_NamespaceIsNotSupported, GetLineInfo(reader)));
                }

                element.Attributes !.Add(new XmlConfigurationElementAttributeValue(reader.LocalName, reader.Value, lineNumber, linePosition));
            }

            // Go back to the element containing the attributes we just processed
            reader.MoveToElement();
        }
コード例 #2
0
        /// <summary>
        /// Read a stream of XML values into a key/value dictionary.
        /// </summary>
        /// <param name="stream">The stream of XML data.</param>
        /// <param name="decryptor">The <see cref="XmlDocumentDecryptor"/> to use to decrypt.</param>
        /// <returns>The <see cref="IDictionary{String, String}"/> which was read from the stream.</returns>
        public static IDictionary <string, string?> Read(Stream stream, XmlDocumentDecryptor decryptor)
        {
            var readerSettings = new XmlReaderSettings()
            {
                CloseInput       = false, // caller will close the stream
                DtdProcessing    = DtdProcessing.Prohibit,
                IgnoreComments   = true,
                IgnoreWhitespace = true
            };

            XmlConfigurationElement?root = null;

            using (XmlReader reader = decryptor.CreateDecryptingXmlReader(stream, readerSettings))
            {
                // keep track of the tree we followed to get where we are (breadcrumb style)
                var currentPath = new Stack <XmlConfigurationElement>();

                XmlNodeType preNodeType = reader.NodeType;

                while (reader.Read())
                {
                    switch (reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        var element = new XmlConfigurationElement(reader.LocalName, GetName(reader));

                        if (currentPath.Count == 0)
                        {
                            root = element;
                        }
                        else
                        {
                            var parent = currentPath.Peek();

                            // If parent already has a dictionary of children, update the collection accordingly
                            if (parent.ChildrenBySiblingName != null)
                            {
                                // check if this element has appeared before, elements are considered siblings if their SiblingName properties match
                                if (!parent.ChildrenBySiblingName.TryGetValue(element.SiblingName, out var siblings))
                                {
                                    siblings = new List <XmlConfigurationElement>();
                                    parent.ChildrenBySiblingName.Add(element.SiblingName, siblings);
                                }
                                siblings.Add(element);
                            }
                            else
                            {
                                // Performance optimization: parents with a single child don't even initialize a dictionary
                                if (parent.SingleChild == null)
                                {
                                    parent.SingleChild = element;
                                }
                                else
                                {
                                    // If we encounter a second child after assigning "SingleChild", we clear SingleChild and initialize the dictionary
                                    var children = new Dictionary <string, List <XmlConfigurationElement> >(StringComparer.OrdinalIgnoreCase);

                                    // Special case: the first and second child have the same sibling name
                                    if (string.Equals(parent.SingleChild.SiblingName, element.SiblingName, StringComparison.OrdinalIgnoreCase))
                                    {
                                        children.Add(element.SiblingName, new List <XmlConfigurationElement>
                                        {
                                            parent.SingleChild,
                                            element
                                        });
                                    }
                                    else
                                    {
                                        children.Add(parent.SingleChild.SiblingName, new List <XmlConfigurationElement> {
                                            parent.SingleChild
                                        });
                                        children.Add(element.SiblingName, new List <XmlConfigurationElement> {
                                            element
                                        });
                                    }

                                    parent.ChildrenBySiblingName = children;
                                    parent.SingleChild           = null;
                                }
                            }
                        }

                        currentPath.Push(element);

                        ReadAttributes(reader, element);

                        // If current element is self-closing
                        if (reader.IsEmptyElement)
                        {
                            currentPath.Pop();
                        }
                        break;

                    case XmlNodeType.EndElement:
                        if (currentPath.Count != 0)
                        {
                            XmlConfigurationElement parent = currentPath.Pop();

                            // If this EndElement node comes right after an Element node,
                            // it means there is no text/CDATA node in current element
                            if (preNodeType == XmlNodeType.Element)
                            {
                                var lineInfo     = reader as IXmlLineInfo;
                                var lineNumber   = lineInfo?.LineNumber;
                                var linePosition = lineInfo?.LinePosition;
                                parent.TextContent = new XmlConfigurationElementTextContent(string.Empty, lineNumber, linePosition);
                            }
                        }
                        break;

                    case XmlNodeType.CDATA:
                    case XmlNodeType.Text:
                        if (currentPath.Count != 0)
                        {
                            var lineInfo     = reader as IXmlLineInfo;
                            var lineNumber   = lineInfo?.LineNumber;
                            var linePosition = lineInfo?.LinePosition;

                            XmlConfigurationElement parent = currentPath.Peek();

                            parent.TextContent = new XmlConfigurationElementTextContent(reader.Value, lineNumber, linePosition);
                        }
                        break;

                    case XmlNodeType.XmlDeclaration:
                    case XmlNodeType.ProcessingInstruction:
                    case XmlNodeType.Comment:
                    case XmlNodeType.Whitespace:
                        // Ignore certain types of nodes
                        break;

                    default:
                        throw new FormatException(SR.Format(SR.Error_UnsupportedNodeType, reader.NodeType, GetLineInfo(reader)));
                    }
                    preNodeType = reader.NodeType;

                    // If this element is a self-closing element,
                    // we pretend that we just processed an EndElement node
                    // because a self-closing element contains an end within itself
                    if (preNodeType == XmlNodeType.Element && reader.IsEmptyElement)
                    {
                        preNodeType = XmlNodeType.EndElement;
                    }
                }
            }

            return(ProvideConfiguration(root));
        }
コード例 #3
0
        private static IDictionary <string, string> ProvideConfiguration(XmlConfigurationElement root)
        {
            var configuration = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);

            if (root == null)
            {
                return(configuration);
            }

            var rootPrefix = new Prefix();

            // The root element only contributes to the prefix via its Name attribute
            if (!string.IsNullOrEmpty(root.Name))
            {
                rootPrefix.Push(root.Name);
            }

            ProcessElementAttributes(rootPrefix, root);
            ProcessElementContent(rootPrefix, root);
            ProcessElementChildren(rootPrefix, root);

            return(configuration);

            void ProcessElement(Prefix prefix, XmlConfigurationElement element)
            {
                ProcessElementAttributes(prefix, element);

                ProcessElementContent(prefix, element);

                ProcessElementChildren(prefix, element);
            }

            void ProcessElementAttributes(Prefix prefix, XmlConfigurationElement element)
            {
                // Add attributes to configuration values
                if (element.Attributes != null)
                {
                    for (var i = 0; i < element.Attributes.Count; i++)
                    {
                        var attribute = element.Attributes[i];

                        prefix.Push(attribute.Attribute);

                        AddToConfiguration(prefix.AsString, attribute.Value, attribute.LineNumber, attribute.LinePosition);

                        prefix.Pop();
                    }
                }
            }

            void ProcessElementContent(Prefix prefix, XmlConfigurationElement element)
            {
                // Add text content to configuration values
                if (element.TextContent != null)
                {
                    var textContent = element.TextContent;
                    AddToConfiguration(prefix.AsString, textContent.TextContent, textContent.LineNumber, textContent.LinePosition);
                }
            }

            void ProcessElementChildren(Prefix prefix, XmlConfigurationElement element)
            {
                if (element.SingleChild != null)
                {
                    var child = element.SingleChild;

                    ProcessElementChild(prefix, child, null);

                    return;
                }

                if (element.ChildrenBySiblingName == null)
                {
                    return;
                }

                // Recursively walk through the children of this element
                foreach (var childrenWithSameSiblingName in element.ChildrenBySiblingName.Values)
                {
                    if (childrenWithSameSiblingName.Count == 1)
                    {
                        var child = childrenWithSameSiblingName[0];

                        ProcessElementChild(prefix, child, null);
                    }
                    else
                    {
                        // Multiple children with the same sibling name. Add the current index to the prefix
                        for (int i = 0; i < childrenWithSameSiblingName.Count; i++)
                        {
                            var child = childrenWithSameSiblingName[i];

                            ProcessElementChild(prefix, child, i);
                        }
                    }
                }
            }

            void ProcessElementChild(Prefix prefix, XmlConfigurationElement child, int?index)
            {
                // Add element name to prefix
                prefix.Push(child.ElementName);

                // Add value of name attribute to prefix
                var hasName = !string.IsNullOrEmpty(child.Name);

                if (hasName)
                {
                    prefix.Push(child.Name);
                }

                // Add index to the prefix
                if (index != null)
                {
                    prefix.Push(index.Value.ToString(CultureInfo.InvariantCulture));
                }

                ProcessElement(prefix, child);

                // Remove index
                if (index != null)
                {
                    prefix.Pop();
                }

                // Remove 'Name' attribute
                if (hasName)
                {
                    prefix.Pop();
                }

                // Remove element name
                prefix.Pop();
            }

            void AddToConfiguration(string key, string value, int?lineNumber, int?linePosition)
            {
#if NETSTANDARD2_1
                if (!configuration.TryAdd(key, value))
                {
                    var lineInfo = lineNumber == null || linePosition == null
                        ? string.Empty
                        : SR.Format(SR.Msg_LineInfo, lineNumber.Value, linePosition.Value);
                    throw new FormatException(SR.Format(SR.Error_KeyIsDuplicated, key, lineInfo));
                }
#else
                if (configuration.ContainsKey(key))
                {
                    var lineInfo = lineNumber == null || linePosition == null
                        ? string.Empty
                        : SR.Format(SR.Msg_LineInfo, lineNumber.Value, linePosition.Value);
                    throw new FormatException(SR.Format(SR.Error_KeyIsDuplicated, key, lineInfo));
                }

                configuration.Add(key, value);
#endif
            }
        }