C# XmlElement.InsertBefore方法代碼示例

 internal static void AddConformanceClaims(XmlElement documentation, WsiProfiles claims)
 {
     claims &= WsiProfiles.BasicProfile1_1;
     if (claims != WsiProfiles.None)
     {
         WsiProfiles conformanceClaims = GetConformanceClaims(documentation);
         claims &= ~conformanceClaims;
         if (claims != WsiProfiles.None)
         {
             XmlDocument ownerDocument = documentation.OwnerDocument;
             if ((claims & WsiProfiles.BasicProfile1_1) != WsiProfiles.None)
             {
                 XmlElement newChild = ownerDocument.CreateElement("wsi", "Claim", "http://ws-i.org/schemas/conformanceClaim/");
                 newChild.SetAttribute("conformsTo", "http://ws-i.org/profiles/basic/1.1");
                 documentation.InsertBefore(newChild, null);
             }
         }
     }
 }

        internal static void AddConformanceClaims(XmlElement documentation, WsiProfiles claims) {
            //
            claims &= SupportedClaims;
            if (claims == WsiProfiles.None)
                return;

            // check already presend claims
            WsiProfiles existingClaims = GetConformanceClaims(documentation);
            claims &= ~existingClaims;
            if (claims == WsiProfiles.None)
                return;

            XmlDocument d = documentation.OwnerDocument;
            if ((claims & WsiProfiles.BasicProfile1_1) != 0) {
                XmlElement claim = d.CreateElement(Soap.ClaimPrefix, Soap.Element.Claim, Soap.ConformanceClaim);
                claim.SetAttribute(Soap.Attribute.ConformsTo, Soap.BasicProfile1_1);
                documentation.InsertBefore(claim, null);
            }
        }

        private void AddSignature(XmlElement parent)
        {
            body.Normalize();

            SignedXml signed = new SamlSignedXml(body);
            signed.SigningKey = sessionCert.PrivateKey;
            signed.SignedInfo.CanonicalizationMethod = SignedXml.XmlDsigExcC14NTransformUrl;
            signed.KeyInfo = new KeyInfo();
            signed.KeyInfo.AddClause(new KeyInfoX509Data(sessionCert, X509IncludeOption.EndCertOnly));

            Reference requestRef = new Reference("#" + requestId);
            requestRef.AddTransform(new XmlDsigEnvelopedSignatureTransform());
            requestRef.AddTransform(new XmlDsigExcC14NTransform());
            signed.AddReference(requestRef);
            signed.ComputeSignature();
            parent.InsertBefore(signed.GetXml(), parent.FirstChild);
        }

		protected void WriteActionGroups (ObjectWriter writer, XmlElement elem)
		{
			if (writer.Format == FileFormat.Native) {
				if (actionGroups != null) {
					foreach (ActionGroup actionGroup in actionGroups)
						elem.InsertBefore (actionGroup.Write (writer), elem.FirstChild);
				}
			}
		}

		private void BeautifyElement(XmlElement e, int indent)
		{
			StringBuilder s = new StringBuilder();
			s.Append('\n');
			for (int i = 0; i < indent; i++)
			{
				s.Append(' ');
			}
			string afterContent = s.ToString();
			for (int i_1 = 0; i_1 < prettyIndent; i_1++)
			{
				s.Append(' ');
			}
			string beforeContent = s.ToString();
			//    We "mark" all the nodes first; if we tried to do this loop otherwise, it would behave unexpectedly (the inserted nodes
			//    would contribute to the length and it might never terminate).
			List<System.Xml.XmlNode> toIndent = new List<System.Xml.XmlNode>();
			bool indentChildren = false;
			for (int i_2 = 0; i_2 < e.ChildNodes.Count; i_2++)
			{
				if (i_2 == 1)
				{
					indentChildren = true;
				}
				if (e.ChildNodes.Item(i_2) is XmlText)
				{
					toIndent.Add(e.ChildNodes.Item(i_2));
				}
				else
				{
					indentChildren = true;
					toIndent.Add(e.ChildNodes.Item(i_2));
				}
			}
			if (indentChildren)
			{
				for (int i_3 = 0; i_3 < toIndent.Count; i_3++)
				{
					e.InsertBefore(e.OwnerDocument.CreateTextNode(beforeContent), toIndent[i_3]);
				}
			}
			XmlNodeList nodes = e.ChildNodes;
			List<XmlElement> list = new List<XmlElement>();
			for (int i_4 = 0; i_4 < nodes.Count; i_4++)
			{
				if (nodes.Item(i_4) is XmlElement)
				{
					list.Add((XmlElement)nodes.Item(i_4));
				}
			}
			foreach (XmlElement elem in list)
			{
				BeautifyElement(elem, indent + prettyIndent);
			}
			if (indentChildren)
			{
				e.AppendChild(e.OwnerDocument.CreateTextNode(afterContent));
			}
		}

        /// <summary>
        /// Appends the specified action to the specified XML action model.  The "group-hint"
		/// attribute of the action to be inserted is compared with the "group-hint" of the
		/// actions in the xml model and an appropriate place to insert the action is determined
		/// based on the MatchScore method of the <see cref="GroupHint"/>.
        /// </summary>
        /// <param name="xmlActionModel">the "action-model" node to insert an action into</param>
        /// <param name="action">the action to be inserted</param>
		/// <returns>a boolean indicating whether anything was added/removed/modified</returns>
        private static bool AppendActionToXmlModel(XmlDocument document, XmlElement xmlActionModel, IAction action)
        {
            if (null != FindXmlAction(xmlActionModel, action))
				return false;
			
			XmlNode insertionPoint = null;
            bool insertBefore = false;
			int currentGroupScore = 0;

			foreach (XmlElement xmlAction in xmlActionModel.GetElementsByTagName("action"))
			{
				string hint = xmlAction.GetAttribute("group-hint");
				var groupHint = new GroupHint(hint);

				int groupScore = action.GroupHint.MatchScore(groupHint);
                if (groupScore > 0 && groupScore >= Math.Abs(currentGroupScore))
                {
                    //"greater than" current score
                    insertionPoint = xmlAction;
                    currentGroupScore = groupScore;
                    insertBefore = false;
                }
                else if (groupScore < 0 && Math.Abs(groupScore) > Math.Abs(currentGroupScore))
                {
                    //"less than"
                    insertionPoint = xmlAction;
                    currentGroupScore = groupScore;
                    insertBefore = true;
                }
			}
						
			XmlElement newXmlAction = CreateXmlAction(document, action);
			
			if (insertionPoint != null)
			{
			    if (insertBefore)
                    xmlActionModel.InsertBefore(newXmlAction, insertionPoint);
                else 
                    xmlActionModel.InsertAfter(newXmlAction, insertionPoint);
			}
			else
				xmlActionModel.AppendChild(newXmlAction);

			return true;
		}

 internal void InsertBefore(XmlElement parent, XmlElement child, XmlElement reference)
 {
     parent.InsertBefore(child, reference);
 }

 protected override void InsertTransformElement(XmlElement targetElement, XmlElement transformElement)
 {
     targetElement.InsertBefore(transformElement, targetElement.ChildNodes.OfType<XmlNode>().FirstOrDefault());
 }

        private void ExtractSharedValues(XmlElement arrayNode)
        {
            var childs = GetChild(arrayNode);
            if (childs.Count < 2) return;//No defaults for less than two item in the array
            if (arrayNode.SelectNodes("Item[@ElementDataType]").Count > 0)//Dont make default for different Data types
                return;
            Dictionary<string, int> dic = new Dictionary<string, int>();
            Dictionary<string, string> propertyValue = new Dictionary<string, string>();
            foreach (XmlNode property in arrayNode.SelectNodes("Item/Property"))
            {
                string key = property.Attributes["PropertyName"].Value;
                if (propertyValue.ContainsKey(key) && propertyValue[key] != property.InnerXml)
                    dic.Remove(key);
                else
                {
                    propertyValue[key] = property.InnerXml;
                    if (dic.ContainsKey(key)) dic[key]++;
                    else dic[key] = 1;
                }
            }
            var defaultItem = xmlDoc.CreateElement("ItemDefaults");

            foreach (var item in dic)
            {
                if (item.Value < childs.Count) continue;
                var nodes = arrayNode.SelectNodes(string.Format("Item/Property[@PropertyName=\"{0}\"]", item.Key));
                foreach (XmlNode node in nodes)
                    node.ParentNode.RemoveChild(node);
                defaultItem.AppendChild(nodes[0]);
            }
            if (GetChild(defaultItem).Count > 0)
                arrayNode.InsertBefore(defaultItem, childs[0]);
        }

        protected override void ExecuteCore(XmlElement element)
        {
            var child = CreateNode(element);

            if (!string.IsNullOrEmpty(After))
            {
                try
                {
                    if (After == "self")
                    {
                        element.ParentNode.InsertAfter(child, element);

                        return;
                    }

                    var node = element.SelectSingleNode(After);

                    if (node != null)
                    {
                        element.InsertAfter(child, node);

                        return;
                    }
                }
                catch (XPathException e)
                {
                    var message = string.Format("'{0}' is not a valid XPath expression.", After);
                    throw new TaskExecutionException(message, e);
                }
                catch (ArgumentException)
                {
                    // The XPath expression is not valid IN THIS CONTEXT, e.g. an attribute was selected
                }
            }

            if (!string.IsNullOrEmpty(Before))
            {
                try
                {
                    if (Before == "self")
                    {
                        element.ParentNode.InsertBefore(child, element);

                        return;
                    }

                    var node = element.SelectSingleNode(Before);

                    if (node != null)
                    {
                        element.InsertBefore(child, node);

                        return;
                    }
                }
                catch (XPathException e)
                {
                    var message = string.Format("'{0}' is not a valid XPath expression.", Before);
                    throw new TaskExecutionException(message, e);
                }
                catch (ArgumentException)
                {
                    // The XPath expression is not valid IN THIS CONTEXT, e.g. an attribute was selected
                }
            }

            element.AppendChild(child);
        }

        private void CollectAntCodeCoverageForNode(string reportDirectory, string include, string exclude, XmlElement node, XmlDocument buildXml, XmlNode instrumentNode, string instrumentedClassesDirectory, string dataFile)
        {
            // add instrument node befor the test node.            
            var parentNode = node.ParentNode;
            parentNode.InsertBefore(instrumentNode, node);

            node.SetAttribute("fork", "true");
            _executionContext.Debug(StringUtil.Format(CodeCoverageConstants.SettingAttributeTemplate, "fork", "true", "test"));

            RemoveSysNodes(node);

            var coberturaCoverageElement = buildXml.CreateElement("sysproperty");
            coberturaCoverageElement.SetAttribute("key", "net.sourceforge.cobertura.datafile");
            coberturaCoverageElement.SetAttribute("file", dataFile);
            node.InsertBefore(coberturaCoverageElement, node.FirstChild);

            var instrumentElement = buildXml.CreateElement("classpath");
            instrumentElement.SetAttribute("location", instrumentedClassesDirectory);
            node.InsertAfter(instrumentElement, node.FirstChild);

            var classPathElement = buildXml.CreateElement("classpath");
            classPathElement.SetAttribute("refid", CodeCoverageConstants.CoberturaClassPathString);
            node.InsertAfter(classPathElement, node.LastChild);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="fp"></param>
        /// <param name="parentEle"></param>
        protected void AddFootnoteResource( FootnoteProperty fp, XmlElement parentEle )
        {
            XmlElement resource = null;
            resource = this.xDoc.CreateElement(DocumentBase.XBRL_LINKBASE_PREFIX, FOOTNOTE_RESOURCE, DocumentBase.XBRL_LINKBASE_URL);

            XmlAttribute resAttr = xDoc.CreateAttribute( DocumentBase.XLINK_PREFIX, TYPE, DocumentBase.XLINK_URI );
            resAttr.Value = RESOURCE;
            resource.SetAttributeNode( resAttr );

            XmlAttribute resRoleAttr = xDoc.CreateAttribute( DocumentBase.XLINK_PREFIX, ROLE, DocumentBase.XLINK_URI );
            resRoleAttr.Value = FOOTNOTE_RESOURCE_ARCROLE;
            resource.SetAttributeNode( resRoleAttr );

            XmlAttribute labelAttr = xDoc.CreateAttribute( DocumentBase.XLINK_PREFIX, LABEL, DocumentBase.XLINK_URI );
            labelAttr.Value = fp.Id;
            resource.SetAttributeNode( labelAttr );

            XmlAttribute langAttr = xDoc.CreateAttribute(XML, LANG, DocumentBase.XBRL_INSTANCE_URL);
            langAttr.Value = fp.language;
            resource.SetAttributeNode( langAttr );

            try
            {
                resource.InnerXml = fp.markupData;
            }
            catch (Exception)
            {
                resource.InnerText = fp.markupData;
            }

            parentEle.AppendChild(resource);

            if ( writeComments )
            {
                XmlComment locComment = xDoc.CreateComment( TraceUtility.FormatStringResource( "XBRLParser.Info.InstanceDocMarkupAddress", fp.address ) );
                parentEle.InsertBefore(locComment, resource);
            }

            fp.HasBeenWritten = true;
        }

        private void AddFootnoteLocator(MarkupProperty mp, XmlElement parentElement)
        {
            XmlElement locator = null;
            locator = xDoc.CreateElement(DocumentBase.XBRL_LINKBASE_PREFIX, LOC, DocumentBase.XBRL_LINKBASE_URL);

            XmlAttribute typeAttr = xDoc.CreateAttribute( DocumentBase.XLINK_PREFIX, TYPE, DocumentBase.XLINK_URI );
            typeAttr.Value = LOCATOR;
            locator.SetAttributeNode( typeAttr );

            XmlAttribute hrefAttr = xDoc.CreateAttribute( DocumentBase.XLINK_PREFIX, HREF, DocumentBase.XLINK_URI );
            hrefAttr.Value = string.Format( HREF_FORMAT, string.Empty, mp.Id );
            locator.SetAttributeNode( hrefAttr );

            XmlAttribute labelAttr = xDoc.CreateAttribute( DocumentBase.XLINK_PREFIX, LABEL, DocumentBase.XLINK_URI );
            labelAttr.Value = string.Format( LABEL_FORMAT, mp.Id );
            locator.SetAttributeNode( labelAttr );

            parentElement.AppendChild(locator);

            if (writeComments && mp.xmlElement != null)
            {
                XmlComment locComment = xDoc.CreateComment( TraceUtility.FormatStringResource( "XBRLParser.Info.InstanceDocFootnoteMarkupAddress", mp.address, mp.xmlElement.Name ) );
                parentElement.InsertBefore(locComment, locator);
            }
        }