C# XmlNode.GetNamespaceOfPrefix方法代码示例

		public static void UpdateManifest(string fullPath) {
			_document = new XmlDocument();
			_document.Load(fullPath);
			
			if (_document == null)
			{
				Debug.LogError("Couldn't load " + fullPath);
				return;
			}

			_manifestNode = FindChildNode(_document, "manifest");
			_namespace = _manifestNode.GetNamespaceOfPrefix("android");
			_applicationNode = FindChildNode(_manifestNode, "application");
			
			if (_applicationNode == null) {
				Debug.LogError("Error parsing " + fullPath);
				return;
			}

			SetPermission("android.permission.INTERNET");

			XmlElement applicationElement = FindChildElement(_manifestNode, "application");
			applicationElement.SetAttribute("name", _namespace, "com.soomla.SoomlaApp");


			foreach(ISoomlaManifestTools manifestTool in ManTools) {
				manifestTool.UpdateManifest();
			}
			
			_document.Save(fullPath);
		}

 /// <summary>
 /// 添加节点属性
 /// </summary>
 /// <param name="xDoc">XmlDocument对象</param>
 /// <param name="node">节点对象</param>
 /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
 /// <param name="attributeName">新属性名称</param>
 /// <param name="attributeValue">属性值</param>
 public static void AddAttribute(XmlDocument xDoc, XmlNode node, string namespaceOfPrefix, string attributeName, string attributeValue)
 {
     string ns = namespaceOfPrefix == null ? null : node.GetNamespaceOfPrefix(namespaceOfPrefix);
     XmlNode xn = xDoc.CreateNode(XmlNodeType.Attribute, attributeName, ns == "" ? null : ns);
     xn.Value = attributeValue;
     node.Attributes.SetNamedItem(xn);
 }

		private static void LoadManifest(){
			_document = new XmlDocument();
			_document.Load(outputFile);
			
			if (_document == null)
			{
				Debug.LogError("Couldn't load " + outputFile);
				return;
			}
			
			_manifestNode = FindChildNode(_document, "manifest");
			_namespace = _manifestNode.GetNamespaceOfPrefix("android");
			_applicationNode = FindChildNode(_manifestNode, "application");
			
			if (_applicationNode == null) {
				Debug.LogError("Error parsing " + outputFile);
				return;
			}
		}

 private static void FindTargetSchemaNode(XmlNode document, XmlNamespaceManager xmlNamespaceManager, XmlNode node, XmlNode thisSchemaNode, string rawTypeName, out XmlNode targetSchemaNode, out TypeReference typeReference)
 {
     string[] typeParts = rawTypeName.Split(':');
     string typeName;
     string typeTargetNamespace;
     if (typeParts.Length == 2)
     {
         typeTargetNamespace = node.GetNamespaceOfPrefix(typeParts[0]);
         typeName = typeParts[1];
         XmlNodeList targetSchemaNodes = document.SelectNodes(".//xs:schema[@targetNamespace='" + typeTargetNamespace + "']", xmlNamespaceManager);
         targetSchemaNode = targetSchemaNodes[0];
     }
     else if (typeParts.Length == 1)
     {
         typeTargetNamespace = thisSchemaNode.Attributes.GetNamedItem("targetNamespace").Value;
         typeName = typeParts[0];
         targetSchemaNode = thisSchemaNode;
     }
     else
     {
         throw new InvalidOperationException("Could not find target schema node for type " + rawTypeName + ".");
     }
     typeReference = new TypeReference(typeTargetNamespace, typeName);
 }

        public static string FindUnusedPrefix(XmlNode node, string prefixHint)
        {
            string pp = prefixHint;
            if (prefixHint == null || prefixHint.Length == 0)
                pp = "n";
            else
            {
                string uri = node.GetNamespaceOfPrefix(pp);
                if (uri == null || uri.Length == 0)
                    return pp;
            }

            int n = 1;
            while (true)
            {
                string s = string.Format(pp+"{0}", n++);
                string uri = node.GetNamespaceOfPrefix(s);
                if (uri == null || uri.Length == 0)
                    return s;
            }
        }

        public static Altova.Types.QName CastToQName(XmlNode node, MemberInfo member)
        {
            int i = node.InnerText.IndexOf(":");
            if (i == -1)
                return new Altova.Types.QName(node.GetNamespaceOfPrefix(""), node.InnerText);

            string prefix = node.InnerText.Substring(0, i);
            string local = node.InnerText.Substring(i + 1);

            string uri = node.GetNamespaceOfPrefix(prefix);

            return new Altova.Types.QName(uri, prefix, local);
        }

		// Namespace Axis
		// Consider a list L containing only namespace nodes in the 
		// axis and in the node-set in lexicographic order (ascending). To begin 
		// processing L, if the first node is not the default namespace node (a node 
		// with no namespace URI and no local name), then generate a space followed 
		// by xmlns="" if and only if the following conditions are met:
		//    - the element E that owns the axis is in the node-set
		//    - The nearest ancestor element of E in the node-set has a default 
		//	    namespace node in the node-set (default namespace nodes always 
		//      have non-empty values in XPath)
		// The latter condition eliminates unnecessary occurrences of xmlns="" in 
		// the canonical form since an element only receives an xmlns="" if its 
		// default namespace is empty and if it has an immediate parent in the 
		// canonical form that has a non-empty default namespace. To finish 
		// processing  L, simply process every namespace node in L, except omit 
		// namespace node with local name xml, which defines the xml prefix, 
		// if its string value is http://www.w3.org/XML/1998/namespace.
		private void WriteNamespacesAxis (XmlNode node, bool visible)
		{
			// Console.WriteLine ("Debug: namespaces");

			XmlDocument doc = node.OwnerDocument;    
			bool has_empty_namespace = false;
			ArrayList list = new ArrayList ();
			for (XmlNode cur = node; cur != null && cur != doc; cur = cur.ParentNode) {
			        foreach (XmlNode attribute in cur.Attributes) {		
					if (!IsNamespaceNode (attribute)) 
			    			continue;
			    	
					// get namespace prefix
					string prefix = string.Empty;
					if (attribute.Prefix == "xmlns") 
						prefix = attribute.LocalName;
			    
				        // check if it is "xml" namespace			    
					if (prefix == "xml" && attribute.Value == "http://www.w3.org/XML/1998/namespace")
						continue;
			    
					// make sure that this is an active namespace
					// for our node
					string ns = node.GetNamespaceOfPrefix (prefix);
					if (ns != attribute.Value) 
						continue;
			    
					// check that it is selected with XPath
					if (!IsNodeVisible (attribute)) 
						continue;

					// check that we have not rendered it yet
					bool rendered = IsNamespaceRendered (prefix, attribute.Value);

					// add to the visible namespaces stack
					if (visible)
						visibleNamespaces.Add (attribute);			      
			    
					if (!rendered)
						list.Add (attribute);
				    
					if (prefix == string.Empty)
						has_empty_namespace = true;
				}
			}

			// add empty namespace if needed		    
			if (visible && !has_empty_namespace && !IsNamespaceRendered (string.Empty, string.Empty)) 
				res.Append (" xmlns=\"\"");
		    
			list.Sort (new XmlDsigC14NTransformNamespacesComparer ());
			foreach (object obj in list) {
				XmlNode attribute = (obj as XmlNode);
				if (attribute != null) {
					res.Append (" ");
					res.Append (attribute.Name);
					res.Append ("=\"");
					res.Append (attribute.Value);
					res.Append ("\"");
				}
			}
		    
			// move the rendered namespaces stack
			if (visible) {
				prevVisibleNamespacesStart = prevVisibleNamespacesEnd;
				prevVisibleNamespacesEnd = visibleNamespaces.Count;	
			}
		}

        private static bool TryFindElementWithAndroidName(
            XmlNode parent,
            string attrNameValue,
            out XmlElement element,
            string elementType = "activity")
        {
            string ns = parent.GetNamespaceOfPrefix("android");
            var curr = parent.FirstChild;
            while (curr != null)
            {
                var currXmlElement = curr as XmlElement;
                if (currXmlElement != null &&
                    currXmlElement.Name == elementType &&
                    currXmlElement.GetAttribute("name", ns) == attrNameValue)
                {
                    element = currXmlElement;
                    return true;
                }

                curr = curr.NextSibling;
            }

            element = null;
            return false;
        }

		void GetTypeQualifiedName (XmlNode node, string qualifiedName, out string name, out string ns)
		{
			int i = qualifiedName.IndexOf (':');
			if (i == -1)
			{
				name = qualifiedName;
				ns = "";
				return;
			}
			
			string prefix = qualifiedName.Substring (0,i);
			name = qualifiedName.Substring (i+1);
			ns = node.GetNamespaceOfPrefix (prefix);
			
			string arrayType = GetArrayType (node, name, ns);
			if (arrayType != null) {
				name = arrayType;
				ns = "";
			}
			else if (ns != MetaData.SchemaNamespace) {
				ns = DecodeNamespace (ns);
			}
			else {
				ns = "";
				name = GetClrFromXsd (name);
			}
		}

 public static XmlName ParseName(XmlNode context, string name, XmlNodeType nt)
 {
     XmlName result = new XmlName();
     XmlConvert.VerifyName(name);
     int i = name.IndexOf(':');
     if (i>0){
         string prefix = result.Prefix = name.Substring(0,i);
         result.LocalName = name.Substring(i + 1);
         if (prefix == "xml") {
             result.NamespaceUri = XmlUri;
         } else if (prefix == "xmlns") {
             result.NamespaceUri = XmlnsUri;
         } else {
             result.NamespaceUri = context.GetNamespaceOfPrefix(prefix);
         }
     } else {
         result.Prefix = "";
         result.LocalName = name;
         if (name == "xmlns") {
             result.NamespaceUri = XmlnsUri;
         } else if (nt == XmlNodeType.Attribute) {
             result.NamespaceUri = ""; // non-prefixed attributes are empty namespace by definition
         } else {
             result.NamespaceUri = context.GetNamespaceOfPrefix("");
         }
     }
     return result;
 }

 /// <summary>
 /// ����ָ���ڵ���ָ�����Ե�ֵ
 /// </summary>
 /// <param name="clsXmlNode">XML�ڵ�</param>
 /// <param name="szPrefix">���Ե�ǰ׺</param>
 /// <param name="szAttrName">������</param>
 /// <param name="szAttrValue">����ֵ</param>
 /// <returns>bool</returns>
 public static bool SetXmlAttrValue(XmlNode clsXmlNode, string szPrefix, string szAttrName, string szAttrValue)
 {
     if (clsXmlNode == null)
         return false;
     XmlDocument clsXmlDoc = clsXmlNode.OwnerDocument;
     if (clsXmlDoc == null)
         return false;
     if (szAttrName == null || szAttrName.Trim() == "")
         return false;
     if (szAttrValue == null)
         szAttrValue = string.Empty;
     try
     {
         XmlAttribute clsAttrNode = clsXmlNode.Attributes.GetNamedItem(szAttrName) as XmlAttribute;
         if (clsAttrNode == null)
         {
             string szNamespaceUri = null;
             if (szPrefix == "xmlns")
                 szNamespaceUri = "http://www.w3.org/2000/xmlns/";
             else if (!GlobalMethods.Misc.IsEmptyString(szPrefix))
                 szNamespaceUri = clsXmlNode.GetNamespaceOfPrefix(szPrefix);
             clsAttrNode = clsXmlDoc.CreateAttribute(szPrefix, szAttrName, szNamespaceUri);
             clsXmlNode.Attributes.Append(clsAttrNode);
         }
         clsAttrNode.InnerText = szAttrValue;
         return true;
     }
     catch (Exception ex)
     {
         LogManager.Instance.WriteLog("GlobalMethods.SetXmlAttrValue"
            , new string[] { "clsXmlNode", "szPrefix", "szAttrName", "szAttrValue" }
             , new object[] { clsXmlNode, szPrefix, szAttrName, szAttrValue }, "�޷�����XML�ڵ������ֵ!", ex);
         return false;
     }
 }