C# XElement.Nodes方法代碼示例

        /// <inheritdoc/>
        protected override void HandleXmlElement(SyntaxNodeAnalysisContext context, DocumentationCommentTriviaSyntax documentation, XmlNodeSyntax syntax, XElement completeDocumentation, Location[] diagnosticLocations)
        {
            if (completeDocumentation != null)
            {
                // We are working with an <include> element
                if (completeDocumentation.Nodes().OfType<XElement>().Any(element => element.Name == XmlCommentHelper.SummaryXmlTag))
                {
                    return;
                }

                if (completeDocumentation.Nodes().OfType<XElement>().Any(element => element.Name == XmlCommentHelper.InheritdocXmlTag))
                {
                    // Ignore nodes with an <inheritdoc/> tag in the included XML.
                    return;
                }
            }
            else
            {
                if (syntax != null)
                {
                    return;
                }

                if (documentation?.Content.GetFirstXmlElement(XmlCommentHelper.InheritdocXmlTag) != null)
                {
                    // Ignore nodes with an <inheritdoc/> tag.
                    return;
                }
            }

            foreach (var location in diagnosticLocations)
            {
                context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
            }
        }

                /// <summary>
                /// Tests the Add methods on Container.
                /// </summary>
                /// <param name="context"></param>
                /// <returns></returns>
                //[Variation(Desc = "ContainerAdd")]
                public void ContainerAdd()
                {
                    XElement element = new XElement("foo");

                    // Adding null does nothing.
                    element.Add(null);
                    Validate.Count(element.Nodes(), 0);

                    // Add node, attrbute, string, some other value, and an IEnumerable.
                    XComment comment = new XComment("this is a comment");
                    XComment comment2 = new XComment("this is a comment 2");
                    XComment comment3 = new XComment("this is a comment 3");
                    XAttribute attribute = new XAttribute("att", "att-value");
                    string str = "this is a string";
                    int other = 7;

                    element.Add(comment);
                    element.Add(attribute);
                    element.Add(str);
                    element.Add(other);
                    element.Add(new XComment[] { comment2, comment3 });

                    Validate.EnumeratorDeepEquals(
                        element.Nodes(),
                        new XNode[] { comment, new XText(str + other), comment2, comment3 });

                    Validate.EnumeratorAttributes(element.Attributes(), new XAttribute[] { attribute });

                    element.RemoveAll();
                    Validate.Count(element.Nodes(), 0);

                    // Now test params overload.
                    element.Add(comment, attribute, str, other);

                    Validate.EnumeratorDeepEquals(
                        element.Nodes(),
                        new XNode[] { comment, new XText(str + other) });

                    Validate.EnumeratorAttributes(element.Attributes(), new XAttribute[] { attribute });

                    // Not allowed to add a document as a child.
                    XDocument document = new XDocument();
                    try
                    {
                        element.Add(document);
                        Validate.ExpectedThrow(typeof(ArgumentException));
                    }
                    catch (Exception ex)
                    {
                        Validate.Catch(ex, typeof(ArgumentException));
                    }
                }

 private IEnumerable< XNode > _ProcessIteration(XElement element, XNode iterVal,
                                                string iterName)
 {
     XNode val = iterVal;
     IEnumerable< XNode > results = _Env.Call( () =>
                                                   {
                                                       /* Bind the iterator symbolic name to the current value */
                                                       if ( val is XContainer )
                                                           /* Nodeset value */
                                                       {
                                                           _Env.DefineNodesetSymbol(
                                                               iterName,
                                                               ( ( XContainer ) val ).
                                                                   Nodes() );
                                                       }
                                                       else /* Text value */
                                                       {
                                                           _Env.DefineTextSymbol( iterName,
                                                                                  val.
                                                                                      ToString
                                                                                      () );
                                                       }
                                                       /* Process loop body */
                                                       return _ProcessNodes( element.Nodes() );
                                                   } );
     return results;
 }

 static bool IsSingleLineText(XElement e)
 {
     if (e.HasAttributes) return false;
     foreach (XNode node in e.Nodes())
         if (!(node is XText) || ((XText)node).Value.Contains("\n")) return false;
     return true;
 }

 public static void PrintChildElement(XElement parent)
 {
     foreach (XElement item in parent.Nodes())
     {
         Console.WriteLine(item.Name);
     }
 }

 private static void AssertSerializedField(XElement docNode, string value) {
     Assert.AreEqual(docNode.Nodes().Count(), 1);
     var fieldNode = docNode.Element("field");
     Assert.IsNotNull(fieldNode);
     Assert.AreEqual("one", fieldNode.Attribute("name").Value);
     Assert.AreEqual(value, fieldNode.Value);
 }

        /// <summary>
        /// Build an expando from an XElement
        /// </summary>
        /// <param name="el"></param>
        /// <returns></returns>
        public static ElasticObject ElasticFromXElement(XElement el)
        {
            var exp = new ElasticObject();

            if (!string.IsNullOrEmpty(el.Value))
                exp.InternalValue = el.Value;

            exp.InternalName = el.Name.LocalName;

            foreach (var a in el.Attributes())
                exp.CreateOrGetAttribute(a.Name.LocalName, a.Value);

            var textNode= el.Nodes().FirstOrDefault();
             if (textNode is XText)
                {
                    exp.InternalContent = textNode.ToString();
                }

            foreach (var c in el.Elements())
            {

                var child = ElasticFromXElement(c);
                child.InternalParent = exp;
                exp.AddElement(child);
            }
            return exp;
        }

        /// <summary>
        /// Get all available tracks from the given library
        /// </summary>
        private List<iTunesTrack> InitiTunesTracks()
        {
            XElement trackDictionary = new XElement("Tracks", from track in _itunesLibraryXDocument.Descendants("plist").Elements("dict").Elements("dict").Elements("dict")
                                                              select new XElement("track",
                                                                from key in track.Descendants("key")
                                                                select new XElement(((string)key).Replace(" ", ""), (string)(XElement)key.NextNode)));

            return (trackDictionary.Nodes().Select(track => new iTunesTrack()
            {
                Id = ((XElement)track).Element("TrackID").ToInt(0),
                Album = ((XElement)track).Element("Album").ToString(string.Empty),
                Artist = ((XElement)track).Element("Artist").ToString(string.Empty),
                AlbumArtist = ((XElement)track).Element("AlbumArtist").ToString(string.Empty),
                BitRate = ((XElement)track).Element("BitRate").ToInt(0),
                Comments = ((XElement)track).Element("Comments").ToString(string.Empty),
                Composer = ((XElement)track).Element("Composer").ToString(string.Empty),
                Genre = ((XElement)track).Element("Genre").ToString(string.Empty),
                Kind = ((XElement)track).Element("Kind").ToString(string.Empty),
                //To be able to have a + signs in the track location, we need to convert it to the correct HTML code before we use the UrlDecode
                Location = WebUtility.UrlDecode(((XElement)track).Element("Location").ToString(string.Empty).Replace(Constants.URI_LOCALHOST, string.Empty).Replace("+", "%2B")).Replace('/', Path.DirectorySeparatorChar),
                Name = ((XElement)track).Element("Name").ToString(string.Empty),
                PlayCount = ((XElement)track).Element("PlayCount").ToInt(0),
                SampleRate = ((XElement)track).Element("SampleRate").ToInt(0),
                Size = ((XElement)track).Element("Size").ToInt64(0),
                //Get the track time in total seconds
                TotalTime = ((XElement)track).Element("TotalTime").ToInt64(0) / 1000,
                TrackNumber = ((XElement)track).Element("TrackNumber").ToInt(0)
            })).ToList();
        }

        private void HandleChildCollections(XElement document, object parentObject)
        {
            IEnumerable<XNode> xNodes = document.Nodes();
            foreach (XElement element in xNodes)
            {
                if (element.Attribute("ObjectType") != null)
                {
                    if (element.Attribute("ObjectType").Value == "Collection")
                    {
                        string assemblyQualifiedClassNameCollection = element.Attribute("AssemblyQualifiedClassName").Value;
                        Type collectionType = Type.GetType(assemblyQualifiedClassNameCollection);
                        System.Collections.IList childObjectCollection = (System.Collections.IList)Activator.CreateInstance(collectionType);

                        IEnumerable<XNode> childNodes = element.Nodes();
                        foreach (XElement childElement in childNodes)
                        {
                            string assemblyQualifiedClassNameChild = childElement.Attribute("AssemblyQualifiedClassName").Value;
                            Type childType = Type.GetType(assemblyQualifiedClassNameChild);
                            object childObject = Activator.CreateInstance(childType);
                            YellowstonePathology.Business.Persistence.XmlPropertyWriter rootXmlPropertyWriter = new Persistence.XmlPropertyWriter(childElement, childObject);
                            rootXmlPropertyWriter.Write();
                            childObjectCollection.Add(childObject);
                        }

                        PropertyInfo collectionPropertyInfo = parentObject.GetType().GetProperty(element.Name.ToString());
                        collectionPropertyInfo.SetValue(parentObject, childObjectCollection, null);
                    }
                }
            }
        }

 /// <summary>
 /// Removes all namespaces from a XDocument
 /// </summary>
 /// <param name="e"></param>
 /// <returns></returns>
 /// <remarks>Borrowed from http://stackoverflow.com/a/7238007/41596</remarks>
 public static XElement RemoveAllNamespaces(XElement e)
 {
     return new XElement(e.Name.LocalName,
                         (from n in e.Nodes()
                          select ((n is XElement) ? RemoveAllNamespaces(n as XElement) : n)),
                         (e.HasAttributes) ? (from a in e.Attributes() select a) : null);
 }

        /// <inheritdoc/>
        protected override void HandleXmlElement(SyntaxNodeAnalysisContext context, DocumentationCommentTriviaSyntax documentation, XmlNodeSyntax syntax, XElement completeDocumentation, Location[] diagnosticLocations)
        {
            if (syntax == null)
            {
                return;
            }

            if (completeDocumentation != null)
            {
                XElement summaryNode = completeDocumentation.Nodes().OfType<XElement>().FirstOrDefault(element => element.Name == XmlCommentHelper.SummaryXmlTag);
                if (summaryNode == null)
                {
                    // Handled by SA1604
                    return;
                }

                if (!XmlCommentHelper.IsConsideredEmpty(summaryNode))
                {
                    return;
                }
            }
            else
            {
                if (!XmlCommentHelper.IsConsideredEmpty(syntax))
                {
                    return;
                }
            }

            foreach (var location in diagnosticLocations)
            {
                context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
            }
        }

        /// <summary>
        /// Parse the HTML node at the given element.
        /// </summary>
        public MarkupHtmlElement(XElement element)
        {
            XAttribute idAttribute = element.Attribute("id");
            if (idAttribute != null && IsPublicId(idAttribute.Value))
            {
                Id = idAttribute.Value;
            }

            MarkupNode childrenNode = MarkupNode.Parse(element.Nodes());
            if (childrenNode == null
                || (childrenNode is MarkupHtmlElement
                    && ((MarkupHtmlElement)childrenNode).Id == null
                    && ((MarkupHtmlElement)childrenNode).ChildNodes == null))
            {
                // This node and everything it contains is plain HTML; use it as is.
                Html = element.ToString(SaveOptions.DisableFormatting);
            }
            else
            {
                // UNDONE: Optimization: Any children which are just HTML can be merged into this node.

                // Extract only the top-level tag information. To do this, create a
                // new element that has only the name and attributes.
                XElement topElement = new XElement(element.Name,
                    element.Attributes()
                );
                Html = topElement.ToString(SaveOptions.DisableFormatting);

                // Add in the children nodes.
                ChildNodes =
                    childrenNode is MarkupElementCollection
                        ? (MarkupElementCollection)childrenNode
                        : new MarkupElementCollection(new MarkupElement[] { (MarkupElement)childrenNode });
            }
        }

 static void parseEntry(XElement en, StreamWriter wr) {
   foreach (var nd in en.Nodes()) {
     if (nd is XElement) wr.Write(string.Format("<{0}>", LowUtils.crlfSpaces(((XElement)nd).Value)));
     else if (nd is XText) wr.Write(LowUtils.crlfSpaces(((XText)nd).Value));
     else throw new Exception();
   }
 }

 /// <summary>
 ///  Common logic for if/ifdef/ifndef/else constructs
 /// </summary>
 /// <param name="conditionalElement"></param>
 /// <param name="condition"></param>
 /// <returns></returns>
 protected IEnumerable< XNode > _ProcessConditional(XElement conditionalElement,
                                                    bool condition)
 {
     return condition
                ? _ProcessNodes( conditionalElement.Nodes() )
                : _ProcessNextElse( conditionalElement );
 }

 public void Collection()
 {
     XElement element = new XElement("Foo",
         new XElement("Bar",
             new XAttribute("id", "bar"),
             "Control content"),
         new XElement("p", "paragraph")
     );
     MarkupNode node = MarkupNode.Parse(element.Nodes());
     Assert.IsInstanceOf<MarkupElementCollection>(node);
     MarkupElementCollection collection = (MarkupElementCollection)node;
     Assert.IsNotNull(collection);
     Assert.AreEqual(2, collection.Count());
     List<MarkupElement> items = new List<MarkupElement>(collection);
     Assert.IsInstanceOf<MarkupControlInstance>(items[0]);
     Assert.IsInstanceOf<MarkupHtmlElement>(items[1]);
     Assert.AreEqual(
         "[\n" +
         "    {\n" +
         "        control: \"Bar\",\n" +
         "        id: \"bar\",\n" +
         "        content: \"Control content\"\n" +
         "    },\n" +
         "    \"<p>paragraph</p>\"\n" +
         "]",
         node.JavaScript());
 }