C# XPathNavigator.CreateNavigator方法代码示例

 public Package(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     this.m_Attributes = new Interface.WATFDictionary<string, string>();
     XPathNavigator copyXPathNavigator = xPathNavigator.CreateNavigator();
     if(copyXPathNavigator.MoveToFirstAttribute())
     {
         if(copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.Executive.Path))
         {
             this.m_Attributes.Add(copyXPathNavigator.Name, Path.Value(xPathNavigator));
         }
         else if(copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.Executive.Prefix))
         {
             this.m_Attributes.Add(copyXPathNavigator.Name, Prefix.Value(xPathNavigator));
         }
         while (copyXPathNavigator.MoveToNextAttribute())
         {
             if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.Executive.Path))
             {
                 this.m_Attributes.Add(copyXPathNavigator.Name, Path.Value(xPathNavigator));
             }
             else if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.Executive.Prefix))
             {
                 this.m_Attributes.Add(copyXPathNavigator.Name, Prefix.Value(xPathNavigator));
             }
         }
     }
 }

 public Load(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     this.m_Attributes = new WATF.Compiler.Interface.WATFDictionary<string, string>();
     XPathNavigator copyXPathNavigator = xPathNavigator.CreateNavigator();
     if (copyXPathNavigator.MoveToFirstAttribute())
     {
         if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.ConfigFile.Name))
         {
             this.m_Attributes.Add(GlobalDefine.Keyword.ConfigFile.Name, Name.Value(xPathNavigator));
         }
         else if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.ConfigFile.Path))
         {
             this.m_Attributes.Add(GlobalDefine.Keyword.ConfigFile.Path, Path.Value(xPathNavigator));
         }
         while (copyXPathNavigator.MoveToNextAttribute())
         {
             if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.ConfigFile.Name))
             {
                 this.m_Attributes.Add(GlobalDefine.Keyword.ConfigFile.Name, Name.Value(xPathNavigator));
             }
             else if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.ConfigFile.Path))
             {
                 this.m_Attributes.Add(GlobalDefine.Keyword.ConfigFile.Path, Path.Value(xPathNavigator));
             }
         }
     }
 }

 internal Element(XPathNavigator node)
     : this(node.Name)
 {
     XPathNavigator navigator = node.CreateNavigator();
     if (navigator.MoveToFirstAttribute())
     {
         do
         {
             AddAttribute(navigator.Name, navigator.Value);
         } while (navigator.MoveToNextAttribute());
     }
 }

 public Test(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     m_TestChilds = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>();
     XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element);
     while (xPathNodeIterator.MoveNext())
     {
         if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Step))
         {
             m_TestChilds.Add(GlobalDefine.Keyword.Executive.Step, new Step.Step(xPathNodeIterator.Current));
         }
     }
 }

 private ConfigFile(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     m_ConfigFileNodes = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>();
     XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element);
     while (xPathNodeIterator.MoveNext())
     {
         if(xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.ConfigFile.Load))
         {
             m_ConfigFileNodes.Add(GlobalDefine.Keyword.ConfigFile.Load, new Load.Load(xPathNodeIterator.Current));
         }
     }
 }

 public Import(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     this.m_ImportChilds = new Interface.WATFDictionary<String, WATF.Compiler.Interface.WATFPathNavigator>();
     XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element);
     while (xPathNodeIterator.MoveNext())
     {
         if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Package))
         {
             m_ImportChilds.Add(xPathNodeIterator.Current.LocalName, new Package.Package(xPathNodeIterator.Current));
         }
     }
 }

 public Var(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     this.m_Attributes = new Interface.WATFDictionary<string, string>();
     XPathNavigator copyXPathNavigator = xPathNavigator.CreateNavigator();
     if (copyXPathNavigator.MoveToFirstAttribute())
     {
         this.m_Attributes.Add(copyXPathNavigator.Name, copyXPathNavigator.Value);
         while (copyXPathNavigator.MoveToNextAttribute())
         {
             this.m_Attributes.Add(copyXPathNavigator.Name, copyXPathNavigator.Value);
         }
     }
 }

 public Action(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     m_ActionChilds = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>();
     XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element);
     while (xPathNodeIterator.MoveNext())
     {
         if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Action))
         {
             m_ActionChilds.Add(GlobalDefine.Keyword.Executive.Action, new Action(xPathNodeIterator.Current));
         }
     }
     this.m_Attributes = new Interface.WATFDictionary<string, string>();
     XPathNavigator copyXPathNavigator = xPathNavigator.CreateNavigator();
     if (copyXPathNavigator.MoveToFirstAttribute())
     {
         this.m_Attributes.Add(copyXPathNavigator.Name, copyXPathNavigator.Value);
         while (copyXPathNavigator.MoveToNextAttribute())
         {
             this.m_Attributes.Add(copyXPathNavigator.Name,copyXPathNavigator.Value);
         }
     }
 }

 public Step(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     m_StepChilds = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>();
     XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element);
     while (xPathNodeIterator.MoveNext())
     {
         if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Var))
         {
             m_StepChilds.Add(GlobalDefine.Keyword.Executive.Var, new Var.Var(xPathNodeIterator.Current));
         }
         else if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Action))
         {
             m_StepChilds.Add(GlobalDefine.Keyword.Executive.Action, new Action.Action(xPathNodeIterator.Current));
         }
     }
 }

 public Executive(XPathNavigator xPathNavigator)
     : base(xPathNavigator)
 {
     XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element);
     m_ExeChilds = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>();
     while (xPathNodeIterator.MoveNext())
     {
         if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Import))
         {
             m_ExeChilds.Add(xPathNodeIterator.Current.LocalName, new Import.Import(xPathNodeIterator.Current));
         }
         else if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Test))
         {
             m_ExeChilds.Add(xPathNodeIterator.Current.LocalName, new Test.Test(xPathNodeIterator.Current));
         }
     }
 }

		public void Read(XPathNavigator navigator, ContentItem item, ReadingJournal journal)
		{
			IDictionary<string, IAttachmentHandler> attachments = _explorer.Map<IAttachmentHandler>(item.GetContentType());
			
			foreach(XPathNavigator attachmentElement in EnumerateChildren(navigator))
			{
				string name = attachmentElement.GetAttribute("name", string.Empty);
				if(attachments.ContainsKey(name))
				{
					XPathNavigator attachmentContents = navigator.CreateNavigator();
					attachmentContents.MoveToFirstChild();
					Attachment a = attachments[name].Read(attachmentContents, item);
					if(a != null)
						journal.Report(a);
				}
			}
		}

        public IList<string> GrabBackDropUrls(XPathNavigator nav)
        {
            List<string> urls = new List<string>();
            XPathNodeIterator nIter = nav.SelectChildren("backdrop", "");
            if (nav.MoveToFollowing("backdrop", ""))
            {
                XPathNavigator localNav = nav.CreateNavigator();
                nav.MoveToParent();
                for (int i = 0; i < nIter.Count; i++)
                {
                    if (localNav.GetAttribute("size", "").ToUpperInvariant().Equals("original".ToUpperInvariant()))
                        urls.Add(localNav.Value);

                    localNav.MoveToNext();
                }
            }
            return urls;
        }

 private void ReadComponents(XPathNavigator manifestNav)
 {
     foreach (XPathNavigator componentNav in manifestNav.CreateNavigator().Select("components/component"))
     {
         int order = ComponentInstallers.Count;
         string type = componentNav.GetAttribute("type", "");
         if (InstallMode == InstallMode.Install)
         {
             string installOrder = componentNav.GetAttribute("installOrder", "");
             if (!string.IsNullOrEmpty(installOrder))
             {
                 order = int.Parse(installOrder);
             }
         }
         else
         {
             string unInstallOrder = componentNav.GetAttribute("unInstallOrder", "");
             if (!string.IsNullOrEmpty(unInstallOrder))
             {
                 order = int.Parse(unInstallOrder);
             }
         }
         if (Package.InstallerInfo != null)
         {
             Log.AddInfo(Util.DNN_ReadingComponent + " - " + type);
         }
         ComponentInstallerBase installer = InstallerFactory.GetInstaller(componentNav, Package);
         if (installer == null)
         {
             Log.AddFailure(Util.EXCEPTION_InstallerCreate);
         }
         else
         {
             ComponentInstallers.Add(order, installer);
             this.Package.InstallerInfo.AllowableFiles += ", " + installer.AllowableFiles;
         }
     }
 }

//.........这里部分代码省略.........
                                    SDKUtilities.DebugLine("[MyMoviesImporter] This appears to be rated PG13");
                                    newTitle.ParentalRating = "PG13";
                                    break;
                                case 5:
                                    SDKUtilities.DebugLine("[MyMoviesImporter] I have NO idea what rating this is");
                                    break;
                                case 6:
                                    SDKUtilities.DebugLine("[MyMoviesImporter] This appears to be rated R");
                                    newTitle.ParentalRating = "R";
                                    break;
                            }
                        else
                            SDKUtilities.DebugLine("[MyMoviesImporter] Error parsing rating: {0} not a number", ratingId);
                    }
                    string ratingReason = GetChildNodesValue(navigator, "Description");
                    if (!string.IsNullOrEmpty(ratingReason))
                        newTitle.ParentalRatingReason = ratingReason;
                }
                navigator.MoveToParent();
            }
            #endregion

            newTitle.Runtime = Int32.Parse(GetChildNodesValue(navigator, "RunningTime"));

            #region persons
            if (navigator.MoveToChild("Persons", ""))
            {
                SDKUtilities.DebugLine("[MyMoviesImporter] Beginning the long, painful process of scanning people");
                if (navigator.HasChildren)
                {
                    XPathNodeIterator nIter = navigator.SelectChildren("Person", "");
                    if (navigator.MoveToFirstChild())
                    {
                        XPathNavigator localNav = navigator.CreateNavigator();
                        navigator.MoveToParent();
                        for (int i = 0; i < nIter.Count; i++)
                        {
                            string name = GetChildNodesValue(localNav, "Name");
                            string role = GetChildNodesValue(localNav, "Role");
                            string type = GetChildNodesValue(localNav, "Type");

                            if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(type))
                            {
                                switch (type)
                                {
                                    case "Actor":
                                        SDKUtilities.DebugLine("[MyMoviesImporter] actor {0}, {1}", name, role);

                                        newTitle.AddActingRole(name, role);
                                        break;
                                    case "Director":
                                        SDKUtilities.DebugLine("[MyMoviesImporter] director {0}", name);

                                        newTitle.AddDirector(new OMLSDKPerson(name));
                                        break;

                                    default:
                                        break;
                                }
                            }
                            localNav.MoveToNext("Person", "");
                        }
                    }
                }
                navigator.MoveToParent();
            }

        private static void WriteElement(TextWriter writer, XPathNavigator nav, int depth, string leadIn)
        {
            writer.Write(leadIn);
            writer.WriteLine(nav.Name);

            WriteNamespaces(writer, nav, leadIn);

            if (nav.HasAttributes)
                WriteAttributes(writer, nav, leadIn);

            if (!nav.HasChildren)
                return;

            var childNav = nav.CreateNavigator();
            childNav.MoveToFirstChild();
            Traverse(writer, childNav, depth + 1);
        }