C# XNode.CreateReader方法代码示例

 public RuntimeOrderPipelinesProcessorConfiguration(XNode xml)
 {
     if (xml == null) throw new ArgumentNullException("xml");
     using (var r = xml.CreateReader())
     {
         base.DeserializeElement(r, false);
     }
 }

        static void Transform(string resourceName, XNode xml, ITaskItem outputFile)
        {
            var xmlTransform = new XslCompiledTransform();

            using (var writer = XmlWriter.Create(outputFile.GetMetadata("FullPath"), new XmlWriterSettings { Indent = true }))
            using (var xsltReader = XmlReader.Create(typeof(xunit).Assembly.GetManifestResourceStream("Xunit.Runner.MSBuild." + resourceName)))
            using (var xmlReader = xml.CreateReader())
            {
                xmlTransform.Load(xsltReader);
                xmlTransform.Transform(xmlReader, writer);
            }
        }

//.........这里部分代码省略.........
                    comm.ToBeOutput = true;
                }
                //comm.SetProperty("Content", comment); //dont call this method so that the comment is not "formatted"
                comm.Content = comment;
                return comm;
            }
            else if (node.NodeType == XmlNodeType.None || node.NodeType == XmlNodeType.Attribute ||
                //node.NodeType == XmlNodeType.ProcessingInstruction || 
                node.NodeType == XmlNodeType.Entity ||
                node.NodeType == XmlNodeType.Document || node.NodeType == XmlNodeType.DocumentFragment ||
                node.NodeType == XmlNodeType.DocumentType || node.NodeType == XmlNodeType.Notation ||
                node.NodeType == XmlNodeType.Whitespace || node.NodeType == XmlNodeType.EndElement ||
                node.NodeType == XmlNodeType.EndEntity || node.NodeType == XmlNodeType.XmlDeclaration
                || node.NodeType == XmlNodeType.SignificantWhitespace)
            {
                Nothing nothing = new Nothing();
                nothing.Document = this;
                nothing.Line = lineInfo.LineNumber;
                nothing.Column = lineInfo.LinePosition;
                return nothing;
            }

            if (!(node is XElement))
                throw new QuicException(string.Format("Unrecognized XML node '{0}'", node), 
                    this.SourcePath, lineInfo.LineNumber, lineInfo.LinePosition);
            XElement elementNode = (XElement)node;
            Element element = null;
            try
            {
                element = (Element)BuildObject(elementNode.Name.LocalName, elementNode.GetPrefixOfNamespace(elementNode.Name.Namespace));
                element.Document = this; //just in case I delete it from BuildObject(...) by mistake
            }
            catch (TypeLoadException ex)
            {
                if (this.OutputOptions.AllowUnknownTags)
                {
                    element = new UnknownElement();
                    element.Document = this;
                    var prefix = elementNode.GetPrefixOfNamespace(elementNode.Name.Namespace);
                    ((UnknownElement)element).Tag = (string.IsNullOrWhiteSpace(prefix) ? "" : prefix + ":") + elementNode.Name.LocalName;
                    ((UnknownElement)element).IsEmptyTag = elementNode.IsEmpty;
                }
                else
                {
                    throw new QuicException(ex.Message, this.SourcePath, lineInfo.LineNumber, lineInfo.LinePosition, ex);
                }
            }
            catch (QuicException)
            {
                throw;
            }
            catch (Exception ex)
            {
                throw new QuicException(ex.Message, this.SourcePath, lineInfo.LineNumber, lineInfo.LinePosition, ex);
            }
            element.Line = lineInfo.LineNumber;
            element.Column = lineInfo.LinePosition;

            //set its properties
            foreach (XAttribute attri in elementNode.Attributes())
            {
                //try
                //{
                if (!attri.IsNamespaceDeclaration)
                    element.SetProperty(attri.Name.LocalName, attri.Value);
                //}
                //catch (Exception ex)
                //{
                //    var attriLineInfo = (IXmlLineInfo)attri;
                //    throw new QuicException(ex.Message, this.SourcePath, attriLineInfo.LineNumber, attriLineInfo.LinePosition, ex);
                //}
            }
            //record the element if it has a name
            if (element.Name != null)
            {
                if (namedElements.ContainsKey(element.Name))
                    throw new QuicException(string.Format("An element with the name '{0}' already exists.", element.Name),
                        this.SourcePath, element.Line, element.Column);
                namedElements.Add(element.Name, element);
            }
            //child tags
            if ((element).IsContainer)
            {
                foreach (XNode child in elementNode.Nodes())
                {
                    var uiElement = BuildElement(child);
                    (element).Elements.Add(uiElement);
                }
            }
            else
            {
                var reader = node.CreateReader();
                reader.MoveToContent();
                string innerXml = reader.ReadInnerXml();
                //((UIElement)element).Content = innerXml;
                element.SetProperty("Content", innerXml);
            }

            return element;
        }

 public XmlOutput(XNode element)
 {
     navigator = new XPathDocument(element.CreateReader()).CreateNavigator();
     manager = new XmlNamespaceManager(navigator.NameTable);
     manager.AddNamespace("r", Namespaces.ShopSchema.NamespaceName);
     manager.AddNamespace("x", Namespaces.XForms.NamespaceName);
 }

 private void WriteToFile( XNode doc, StreamWriter file )
 {
     try
     {
         XmlReader xr = doc.CreateReader( ) ;
         Stylesheet.Transform( xr, null, file.BaseStream ) ;
     }
     catch ( XsltException e )
     {
         Trace.TraceError( e.Message ) ;
         throw ;
     }
 }

 private string GetContentToEncrypt(XNode element)
 {
     var reader = element.CreateReader();
     reader.MoveToContent();
     return reader.ReadInnerXml();
 }

        public ConstantExpression(XNode value)
            : this(value, DbType.AnsiStringFixedLength)
        {
            if (value == null) {
                throw new ArgumentNullException(
                    "value",
                    "The value passed to a constant XNode expression must not be null");
            }

            // TODO reader is IDisposable remove that from here
            this.Value = new SqlXml(value.CreateReader());
            this.DbType = DbType.Xml;
        }