C# XmlDocument.AppendElement方法代碼示例

        public void OnSaveSettings()
        {
            XmlDocument settingsDoc = new XmlDocument();
            XmlElement root = settingsDoc.AppendElement("ProjectT");

            root.AppendAttribute("Version", s_version);

            foreach (IModule module in Modules)
            {
                XmlElement moduleElement = root.AppendElement(module.Name);
                module.OnSaveSettings(moduleElement);
            }

            settingsDoc.Save(settingsFile);
        }

        public bool AddHistoryItemOld(HistoryItemOld HistoryItemOld)
        {
            if (!string.IsNullOrEmpty(xmlPath))
            {
                lock (thisLock)
                {
                    XmlDocument xml = new XmlDocument();

                    if (File.Exists(xmlPath))
                    {
                        xml.Load(xmlPath);
                    }

                    if (xml.ChildNodes.Count == 0)
                    {
                        xml.AppendChild(xml.CreateXmlDeclaration("1.0", "UTF-8", null));
                        xml.AppendElement("HistoryItemOlds");
                    }

                    XmlNode rootNode = xml.ChildNodes[1];

                    if (rootNode.Name == "HistoryItemOlds")
                    {
                        HistoryItemOld.ID = Helpers.GetRandomAlphanumeric(12);

                        XmlNode HistoryItemOldNode = rootNode.PrependElement("HistoryItemOld");

                        HistoryItemOldNode.AppendElement("ID", HistoryItemOld.ID);
                        HistoryItemOldNode.AppendElement("Filename", HistoryItemOld.Filename);
                        HistoryItemOldNode.AppendElement("Filepath", HistoryItemOld.Filepath);
                        HistoryItemOldNode.AppendElement("DateTimeUtc", HistoryItemOld.DateTimeUtc.ToString("o"));
                        HistoryItemOldNode.AppendElement("Type", HistoryItemOld.Type);
                        HistoryItemOldNode.AppendElement("Host", HistoryItemOld.Host);
                        HistoryItemOldNode.AppendElement("URL", HistoryItemOld.URL);
                        HistoryItemOldNode.AppendElement("ThumbnailURL", HistoryItemOld.ThumbnailURL);
                        HistoryItemOldNode.AppendElement("DeletionURL", HistoryItemOld.DeletionURL);
                        HistoryItemOldNode.AppendElement("ShortenedURL", HistoryItemOld.ShortenedURL);

                        xml.Save(xmlPath);

                        return true;
                    }
                }
            }

            return false;
        }

        protected virtual void SaveSettings()
        {
            var settingsDoc = new XmlDocument();
            var root = settingsDoc.AppendElement(SettingsNode);

            root.AppendAttribute("Version", Version);

            foreach (IModule module in Modules)
            {
                XmlElement moduleElement = root.AppendElement(module.GetCodeName());
                module.OnSaveSettings(moduleElement);
            }

            try
            {
                settingsDoc.Save(SettingsFile);
            }
            catch (System.Exception)
            {
                // TODO: log error saving file
            }
        }

        internal void GlobalizeResources()
        {
            log.InfoFormat("Globalizing resources for category '{0}' in directory '{1}'",
                arguments["category"], categoryPath);

            DateTime started = DateTime.Now;
            XmlDocument summaryDoc = new XmlDocument();
            XmlElement internationalization = summaryDoc.AppendElement(summaryDoc.CreateElement("internationalization"));

            internationalization.SetAttribute("date", started.ToString("dd-MM-yyyy"));
            internationalization.SetAttribute("time", started.ToString("hh:mm:ss"));

            XmlElement result = internationalization.AppendElement(summaryDoc.CreateElement("result"));
            XmlElement categorySummary = result.AppendElement(summaryDoc.CreateElement("category"));
            categorySummary.SetAttribute("name", arguments["category"]);

            CategoryInfo info = context.ProjectConfiguration.Categories[arguments["category"]];
            XmlElement localesElement = categorySummary.AppendElement(summaryDoc.CreateElement("locales"));
            foreach (string name in info.Locales)
            {
                LocaleInfo locale = context.ProjectConfiguration.Locales[name];
                XmlElement categoryNode = localesElement.AppendElement(summaryDoc.CreateElement("locale"));
                categoryNode.SetAttribute("name", name);
                categoryNode.SetAttribute("dictionaries", string.Join(", ", locale.DictionaryNames));
            }

            log.DebugFormat("Category {0} is configured for {1} locales: {2}",
                arguments["category"], info.Locales.Count, string.Join(",", info.Locales.ToArray()));

            XmlElement resourcesElement = categorySummary.AppendElement(summaryDoc.CreateElement("resources"));
            resourcesElement.SetAttribute("path", arguments["targetPath"]);

            if (Directory.Exists(categoryPath))
            {
                var files = this.GetFiles();
                if (files.Count() == 0)
                {
                    log.Info("No globalizable files found.");
                }
                else
                {
                    IEnumerable<XmlResource> resources = this.GetGlobalizableResources();
                    foreach (XmlResource resource in resources)
                    {
                        log.InfoFormat("Processing {0}", resource.Name.Signature);
                        InternationalizationSummary summary = resource.Globalize();
                        XmlElement summaryElement = summary.ToXml(summaryDoc);
                        resourcesElement.AppendChild(summaryElement);
                    }
                }
            }
            else
            {
                log.DebugFormat("The target directory '{0}' for category {1} doesn't exist.",
                    categoryPath, arguments["category"]);
            }

            DateTime completed = DateTime.Now;
            TimeSpan elapsed = new TimeSpan(completed.Ticks - started.Ticks);
            internationalization.SetAttribute("duration", string.Format("{0}.{1:D3}s", elapsed.Seconds, elapsed.Milliseconds));

            if (!string.IsNullOrWhiteSpace(arguments["reportpath"]))
                this.SummarizeOverview(summaryDoc, arguments["reportpath"]);
        }

        private EntityResult GetClientResourceReader(SageContext context, string sourcePath)
        {
            XmlDocument document = new XmlDocument();
            XmlElement rootNode = document.AppendElement(document.CreateElement("kelp:resources", Kelp.XmlNamespaces.KelpNamespace));
            XmlReader reader = new XmlNodeReader(rootNode);

            string sourcePathAbsolute = context.Path.Resolve(sourcePath.StartsWith("/") ? sourcePath : "~/" + sourcePath);
            string sourcePathRelative = context.Path.GetRelativeWebPath(sourcePathAbsolute, true);
            if (sourcePathAbsolute == null)
                return new EntityResult { Entity = reader, Dependencies = new List<string>() };

            string type = Path.GetExtension(sourcePathAbsolute).Replace(".", string.Empty).ToLower();
            if (!File.Exists(sourcePathAbsolute))
            {
                XmlElement resourceNode = rootNode.AppendElement(document.CreateElement("kelp:resource", Kelp.XmlNamespaces.KelpNamespace));
                resourceNode.SetAttribute("type", type);
                resourceNode.SetAttribute("path", sourcePathAbsolute);
                resourceNode.SetAttribute("src", sourcePathRelative);
                resourceNode.SetAttribute("exists", "false");
                log.ErrorFormat("The resource include file for '{0}' doesn't exist", sourcePathRelative);
                return new EntityResult { Entity = reader, Dependencies = new List<string>() };
            }

            CodeFile file = CodeFile.Create(sourcePathAbsolute, sourcePathRelative);
            if (context.ProjectConfiguration.IsDebugEnabled)
            {
                try
                {
                    foreach (string absolutePath in file.References.Keys)
                    {
                        string relativePath = file.References[absolutePath];
                        XmlElement resourceNode = rootNode.AppendElement(document.CreateElement("kelp:resource", Kelp.XmlNamespaces.KelpNamespace));
                        resourceNode.SetAttribute("path", absolutePath);
                        resourceNode.SetAttribute("type", type);

                        if (File.Exists(absolutePath))
                        {
                            string path = string.Format(RelativeFilePathInDevelopmentSetup, context.Path.GetRelativeWebPath(absolutePath, true));
                            resourceNode.SetAttribute("src", path);
                            resourceNode.SetAttribute("exists", "true");
                        }
                        else
                        {
                            resourceNode.SetAttribute("src", relativePath);
                            resourceNode.SetAttribute("exists", "false");
                        }
                    }
                }
                catch (Exception ex)
                {
                    log.ErrorFormat("Could not process the code file includes: " + ex.Message);
                }
            }
            else
            {
                XmlElement resourceNode = rootNode.AppendElement(document.CreateElement("kelp:resource", Kelp.XmlNamespaces.KelpNamespace));
                resourceNode.SetAttribute("src", string.Format(RelativeFilePathInProductionSetup, sourcePath, file.ETag));
                resourceNode.SetAttribute("type", type);
                resourceNode.SetAttribute("exists", "true");
            }

            return new EntityResult { Entity = reader, Dependencies = new List<string>(file.References.Keys) };
        }

        /// <summary>
        /// Renders the exception to the specified <paramref name="writer"/>
        /// </summary>
        /// <param name="writer">The writer to render the exception to.</param>
        public virtual void RenderWithoutContext(TextWriter writer)
        {
            Contract.Requires<ArgumentNullException>(writer != null);

            XmlDocument document = new XmlDocument();
            XmlElement documentElement = document.AppendElement(this.ConvertToXml(this.Exception, document));
            Exception inner = this.Exception.InnerException;

            while (inner != null)
            {
                documentElement.AppendChild(this.ConvertToXml(inner, document));
                inner = inner.InnerException;
            }

            documentElement.SetAttribute("date", DateTime.Now.ToString("dd-MM-yyyy"));
            documentElement.SetAttribute("time", DateTime.Now.ToString("hh:mm:ss"));

            XmlReader xslReader = this.StylesheetPath.StartsWith(EmbeddedResourceResolver.Scheme)
                ? XmlReader.Create(EmbeddedResourceResolver.GetStream(this.StylesheetPath), null, this.StylesheetPath)
                : XmlReader.Create(this.StylesheetPath);

            XslCompiledTransform xslTransform = new XslCompiledTransform();
            xslTransform.Load(xslReader, new XsltSettings(true, true), new UrlResolver());

            XmlWriter xmlwr = XmlWriter.Create(writer, xslTransform.OutputSettings);
            xslTransform.Transform(document, xmlwr);
        }

        /// <summary>
        /// Renders the exception to the specified <paramref name="writer"/>
        /// </summary>
        /// <param name="writer">The writer to render the exception to.</param>
        /// <param name="context">The context under which this code is executing.</param>
        public virtual void Render(TextWriter writer, SageContext context)
        {
            Contract.Requires<ArgumentNullException>(context != null);
            Contract.Requires<ArgumentNullException>(writer != null);

            XmlDocument document = new XmlDocument();
            XmlElement documentElement = document.AppendElement(this.ConvertToXml(this.Exception, document));
            Exception inner = this.Exception.InnerException;

            while (inner != null)
            {
                documentElement.AppendChild(this.ConvertToXml(inner, document));
                inner = inner.InnerException;
            }

            documentElement.AppendChild(context.ToXml(document));
            documentElement.SetAttribute("date", DateTime.Now.ToString("dd-MM-yyyy"));
            documentElement.SetAttribute("time", DateTime.Now.ToString("hh:mm:ss"));

            XsltTransform processor = XsltTransform.Create(context, this.StylesheetPath);
            XmlWriter xmlwr = XmlWriter.Create(writer, processor.OutputSettings);

            processor.Transform(documentElement, xmlwr, context, this.GetTransformArguments(context));
        }

        /// <summary>
        /// Wraps the previously processed view configuration input XML with the standard XML envelope that contains 
        /// information about the current request, and the resources referenced by the modules and libraries in use by the 
        /// the view.
        /// </summary>
        /// <param name="viewContext">The view context that contains the <see cref="ViewModel"/> that resulted from
        /// previously processing the view configuration.</param>
        /// <returns>
        /// The actual XML document that will be used as input for the final XSLT transform.
        /// </returns>
        public XmlDocument PrepareViewXml(ViewContext viewContext)
        {
            var startTime = DateTime.Now.Ticks;
            ViewModel model = viewContext.ViewData.Model as ViewModel;

            string action = "action";
            if (model != null)
            {
                action = model.ViewConfiguration.Name;
            }
            else if (this.ViewData["Action"] != null)
            {
                action = this.ViewData["Action"].ToString();
            }

            XmlDocument result = new XmlDocument();
            XmlElement viewRoot = result.AppendElement("sage:view", XmlNamespaces.SageNamespace);
            viewRoot.SetAttribute("controller", this.Name);
            viewRoot.SetAttribute("action", action);
            viewRoot.AppendElement(this.Context.ToXml(result));

            log.DebugFormat("Document create");
            XmlElement responseNode = viewRoot.AppendElement("sage:response", XmlNamespaces.SageNamespace);

            if (messages.Count > 0)
            {
                XmlElement messagesNode = responseNode.AppendElement("sage:messages", XmlNamespaces.SageNamespace);
                foreach (var message in messages)
                {
                    messagesNode.AppendChild(message.ToXml(result));
                }
            }

            try
            {
                if (model != null && model.ConfigNode != null)
                {
                    //// make sure resources are ordered properly:
                    ////  1. by resource type (icon, style, script)
                    ////  2. by project dependency
                    ////  3. by module dependency
                    var installOrder = Project.InstallOrder;
                    var inputResources = model.Resources
                        .Where(r => r.IsValidFor(this.Context.UserAgentID))
                        .OrderBy((r1, r2) =>
                            {
                                if (r1.Type != r2.Type)
                                    return r1.Type.CompareTo(r2.Type);

                                if (r1.ProjectId == r2.ProjectId)
                                    return model.Resources.IndexOf(r1).CompareTo(model.Resources.IndexOf(r2));

                                return installOrder.IndexOf(r1.ProjectId).CompareTo(installOrder.IndexOf(r2.ProjectId));
                            })
                        .ToList();

                    log.DebugFormat("Resources ordered");
                    if (inputResources.Count != 0)
                    {
                        XmlElement resourceRoot = responseNode.AppendElement("sage:resources", XmlNamespaces.SageNamespace);

                        List<Resource> headResources = inputResources.Where(r => r.Location == Sage.ResourceLocation.Head).ToList();
                        List<Resource> bodyResources = inputResources.Where(r => r.Location == Sage.ResourceLocation.Body).ToList();
                        List<Resource> dataResources = inputResources.Where(r => r.Location == Sage.ResourceLocation.Data).ToList();

                        if (dataResources.Count != 0)
                        {
                            XmlNode dataNode = resourceRoot.AppendElement("sage:data", XmlNamespaces.SageNamespace);
                            foreach (Resource resource in dataResources)
                            {
                                var time = DateTime.Now;
                                dataNode.AppendChild(resource.ToXml(result, this.Context));
                                var elapsed = (DateTime.Now - time).Milliseconds;
                                if (elapsed > 0)
                                    log.DebugFormat("Added '{0}' to sage:data in {1}ms", resource.Name, elapsed);
                            }
                        }

                        if (headResources.Count != 0)
                        {
                            XmlNode headNode = resourceRoot.AppendElement("sage:head", XmlNamespaces.SageNamespace);
                            foreach (Resource resource in headResources)
                            {
                                var time = DateTime.Now;
                                headNode.AppendChild(resource.ToXml(result, this.Context));
                                var elapsed = (DateTime.Now - time).Milliseconds;
                                if (elapsed > 0)
                                    log.DebugFormat("Added '{0}' to sage:head in {1}ms", resource.Name.Or(resource.Path), elapsed);
                            }
                        }
//.........這裏部分代碼省略.........