C# XmlSerializerNamespaces.ToArray方法代码示例

		public XmlSerializerNamespaceResolver(XmlSerializerNamespaces serializerNamespaces) {
			serializerNamespaces.ToArray().ForEach(qns => {
				if (!qns.IsEmpty) {
					m_namespaces.Add(qns.Name, qns.Namespace);
				}
			});
		}

		internal void Initialize (XmlWriter writer, XmlSerializerNamespaces nss)
		{
			this.writer = writer;
			if (nss != null)
			{
				namespaces = new ArrayList ();
				foreach (XmlQualifiedName ns in nss.ToArray())
					if (ns.Name != "" && ns.Namespace != "")
						namespaces.Add (ns);
			}	
		}

		protected void WriteStartElement (string name, string ns, Object o, bool writePrefixed, XmlSerializerNamespaces xmlns)
		{
			WriteStartElement (name, ns, o, writePrefixed, xmlns != null ? xmlns.ToArray () : null);
		}

        //---------------------------------------------------------------------------------------------------------------------
        /// <summary>Creates an OpenSearchParameterValueSet instance based on the specified OpenSearch template and optional additional parameter information.</summary>
        /// <returns>A new OpenSearchParameterValueSet instance.</returns>
        /// <param name="template">An OpenSearch template URL.</param>
        /// <param name="origParams">An array of objects containing parameter information as defined by the OpenSearch Parameter extension.</returns>
        public static OpenSearchParameterValueSet FromOpenSearchDescription(string template, OpenSearchDescriptionUrlParameter[] origParams = null, XmlSerializerNamespaces namespaces = null)
        {
            OpenSearchParameterValueSet result = new OpenSearchParameterValueSet();

            Dictionary<string, OpenSearchDescriptionUrlParameter> tempParameters = new Dictionary<string, OpenSearchDescriptionUrlParameter>();
            Dictionary<string, string> tempNamespaces = null;
            if (origParams != null) {
                foreach (OpenSearchDescriptionUrlParameter origParam in origParams) tempParameters.Add(origParam.Name, origParam);
            }

            if (namespaces != null) {
                result.nameTable = new NameTable();
                tempNamespaces = new Dictionary<string, string>();
                foreach (XmlQualifiedName qn in namespaces.ToArray()) {
                    tempNamespaces.Add(qn.Name, result.nameTable.Add(qn.Namespace));
                }
            }

            // Make sure URL is valid
            Match match = urlRegex.Match(template);
            if (!match.Success) throw new OpenSearchException(String.Format("Invalid URL template: {0}", template));

            // Split by query string parameter and add parameter definitions to the internal dictionaries:
            // parameters can be settable (e.g. name={key}, name={prefix:key}) or fixed (name=value)
            string[] items = match.Groups[1].Value.Split('&');
            foreach (string item in items) {
                Match match2 = parameterDefinitionRegex.Match(item);
                if (!match2.Success) continue;
                string name = match2.Groups[1].Value;
                OpenSearchParameterDefinition paramDef;
                if (match2.Groups[3].Success) { // parameter is settable
                    string identifier = match2.Groups[3].Value;
                    string identifierNamespaceUri = null, identifierLocalName = null;
                    if (tempNamespaces != null) {
                        string[] parts = identifier.Split(':');
                        if (parts.Length == 2) {
                            identifierNamespaceUri = tempNamespaces.ContainsKey(parts[0]) ? tempNamespaces[parts[0]] : null;
                            if (identifierNamespaceUri != null) identifierLocalName = parts[1];
                        }
                    }
                    paramDef = new OpenSearchParameterDefinition(name, identifier, identifierNamespaceUri, identifierLocalName, tempParameters.ContainsKey(name) ? tempParameters[name] : null);
                    result.parametersByIdentifier[identifier] = paramDef;
                } else { // parameter is fixed
                    paramDef = new OpenSearchParameterDefinition(name);
                    result.values[paramDef] = new string[] {match2.Groups[2].Value};
                }
                result.parametersByName[paramDef.Name] = paramDef;
            }

            return result;
        }

		protected void WriteStartElement (string name, string ns, Object o, bool writePrefixed, XmlSerializerNamespaces xmlns)
		{
			if (xmlns == null)
				throw new ArgumentNullException ("xmlns");
			WriteStartElement (name, ns, o, writePrefixed, xmlns.ToArray ());
		}

		public XmlSerializerNamespaces(XmlSerializerNamespaces namespaces)
			: this(namespaces.ToArray())
		{}

 private String GetNamespace( XmlSerializerNamespaces namespaces )
 {
     var sb = new StringBuilder();
     foreach (XmlQualifiedName name in namespaces.ToArray())
     {
         sb.Append( name.Namespace );
     }
     return sb.ToString();
 }

        /// <summary>
        ///   Initializes a new instance of the <see cref = "XmppSerializer" /> class.
        /// </summary>
        /// <param name = "elementName">Name of the element.</param>
        /// <param name = "schema">The schema.</param>
        /// <param name = "prefix">The prefix.</param>
        /// <param name = "defaultNamespace">The default namespace.</param>
        /// <param name = "serializerType">Type of the serializer.</param>
        private XmppSerializer(string elementName, string schema, string prefix, string defaultNamespace, Type serializerType)
        {
            this.elementName = elementName;
            this.serializerType = serializerType;
            this.schema = schema;
            this.prefix = prefix;
            this.defaultNamespace = defaultNamespace;
            serializer = new XmlSerializer(serializerType);
            nameTable = new NameTable();
            nsMgr = new XmlNamespaceManager(nameTable);
            context = new XmlParserContext(nameTable, nsMgr, null, XmlSpace.None);
            namespaces = new XmlSerializerNamespaces();
            namespaces.Add(prefix, defaultNamespace);

            foreach (XmlQualifiedName name in namespaces.ToArray())
            {
                nsMgr.AddNamespace(name.Name, name.Namespace);
            }
        }