C# XmlWriter.WriteElement方法代码示例

 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     foreach(var interceptorElement in Interceptors)
     {
         writer.WriteElement("interceptor", interceptorElement.SerializeContent);
     }
 }

 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     foreach(var policy in Policies)
     {
         writer.WriteElement("policy", policy.SerializeContent);
     }
 }

 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     foreach(var param in Parameters)
     {
         writer.WriteElement("param", param.SerializeContent);
     }
 }

 private void SerializeContainerConfiguringElements(XmlWriter writer)
 {
     foreach(var element in ConfiguringElements)
     {
         string tag = ExtensionElementMap.GetTagForExtensionElement(element);
         writer.WriteElement(tag, element.SerializeContent);
     }
 }

 public override void WriteXml(XmlWriter writer)
 {
     // Write tag attributes
     base.WriteXml(writer);
     writer.WriteElement(PeptideSettings);
     writer.WriteElement(TransitionSettings);
     writer.WriteElement(DataSettings);
     if (MeasuredResults != null)
         writer.WriteElement(MeasuredResults);
     if (!DocumentRetentionTimes.IsEmpty)
         writer.WriteElement(DocumentRetentionTimes);
 }

        public override void SerializeContent(XmlWriter writer)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(writer, "writer");

            writer.WriteAttributeString(NamePropertyName, this.Name);
            foreach (var matchingRuleElement in this.MatchingRules)
            {
                writer.WriteElement("matchingRule", matchingRuleElement.SerializeContent);
            }
            foreach (var callHandlerElement in this.CallHandlers)
            {
                writer.WriteElement("callHandler", callHandlerElement.SerializeContent);
            }
        }

 /// <summary>
 /// Write the contents of this element to the given <see cref="XmlWriter"/>.
 /// </summary>
 /// <remarks>The caller of this method has already written the start element tag before
 /// calling this method, so deriving classes only need to write the element content, not
 /// the start or end tags.</remarks>
 /// <param name="writer">Writer to send XML content to.</param>
 public override void SerializeContent(XmlWriter writer)
 {
     writer.WriteAttributeString(NamePropertyName, Name);
     foreach(var matchingRuleElement in MatchingRules)
     {
         writer.WriteElement("matchingRule", matchingRuleElement.SerializeContent);
     }
     foreach(var callHandlerElement in CallHandlers)
     {
         writer.WriteElement("callHandler", callHandlerElement.SerializeContent);
     }
 }

 private void SerializeInjectionMembers(XmlWriter writer)
 {
     foreach(var member in InjectionMembers)
     {
         writer.WriteElement(member.ElementName, member.SerializeContent);
     }
 }

        public override void SerializeContent(XmlWriter writer)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(writer, "writer");

            writer.WriteAttributeString(TypePropertyName, TypeName);
            writer.WriteAttributeIfNotEmpty(MapToPropertyName, MapToName)
                .WriteAttributeIfNotEmpty(NamePropertyName, Name);

            if(!string.IsNullOrEmpty(Lifetime.TypeName))
            {
                writer.WriteElement("lifetime", Lifetime.SerializeContent);
            }

            SerializeInjectionMembers(writer);
        }

        public void WriteXml(XmlWriter writer)
        {
            // Write attributes
            writer.WriteAttribute(ATTR.pick, Pick);
            if (RankId != null || _rankIdName != null)
            {
                // If libraries were never connected properly, then _rankIdName may still contain
                // the rank ID.
                writer.WriteAttribute(ATTR.rank_type, RankId != null ? RankId.Value : _rankIdName);
                writer.WriteAttributeNullable(ATTR.peptide_count, PeptideCount);
            }
            writer.WriteAttribute(ATTR.document_library, HasDocumentLibrary);

            // Write child elements
            var libraries = (_libraries.Count > 0 || _disconnectedLibraries == null ?
                _libraries : _disconnectedLibraries);

            if (libraries.Count > 0)
            {
                // writer.WriteElements(_libraries, LIBRARY_HELPERS);
                for (int i = 0; i < libraries.Count; i++)
                {
                    // First make sure it's not the document library
                    var spec = (!ReferenceEquals(libraries, _disconnectedLibraries) ? _librarySpecs[i] : null);
                    if (spec == null || !spec.IsDocumentLibrary)
                    {
                        // If there is a library, write it.  Otherwise, write the
                        // library spec.
                        var item = libraries[i];
                        if (item == null)
                        {
                            if (spec != null && !spec.IsDocumentLocal)
                            {
                                IXmlElementHelper<LibrarySpec> helper = XmlUtil.FindHelper(spec, LIBRARY_SPEC_HELPERS);
                                if (helper == null)
                                    throw new InvalidOperationException(
                                        Resources.
                                            PeptideLibraries_WriteXml_Attempt_to_serialize_list_containing_invalid_type);
                                writer.WriteElement(helper.ElementNames[0], spec);
                            }
                        }
                        else
                        {
                            IXmlElementHelper<Library> helper = XmlUtil.FindHelper(item, LIBRARY_HELPERS);
                            if (helper == null)
                                throw new InvalidOperationException(
                                    Resources.
                                        PeptideLibraries_WriteXml_Attempt_to_serialize_list_containing_invalid_type);
                            writer.WriteElement(helper.ElementNames[0], item);
                        }
                    }
                }
            }
        }

        private void ExportCollada_NodeSub(XmlWriter xml, IReadOnlyList<string> boneNames, Kn5Node node) {
            xml.WriteStartElement("node");
            xml.WriteAttributeStringSafe("id", node.Name);
            xml.WriteAttributeStringSafe("sid", node.Name);
            xml.WriteAttributeStringSafe("name", node.Name);

            xml.WriteAttributeString("layer", node.Active ? "Visible" : "Hidden");
            xml.WriteAttributeString("type", node.NodeClass == Kn5NodeClass.Base && boneNames.Contains(node.Name) ? "JOINT" : "NODE");

            if (node.Children?.FirstOrDefault()?.NodeClass != Kn5NodeClass.SkinnedMesh) {
                xml.WriteElement("matrix",
                        "sid", "transform",
                        node.NodeClass == Kn5NodeClass.Base ? XmlWriterExtension.MatrixToCollada(node.Transform) : "1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0");
            }

            if (IsMultiMaterial(node) && node.Children != null) {
                xml.WriteStartElement("instance_geometry");
                xml.WriteAttributeStringSafe("url", $"#{node.Name}-mesh");
                ExportCollada_NodeSub_BindMaterial(xml, node.Children.Select(x => x.MaterialId).ToArray());
                xml.WriteEndElement();
            } else {
                ExportCollada_NodeSub_Inner(xml, boneNames, node);
            }

            xml.WriteEndElement(); // node
        }

        private void ExportCollada_Mesh(XmlWriter xml, string name, IReadOnlyList<Kn5Node> unsorted) {
            xml.WriteStartElement("geometry");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh");
            xml.WriteAttributeStringSafe("name", name);

            xml.WriteStartElement("mesh");

            var nodes = unsorted.Count == 1 ? unsorted :
                    unsorted.OrderBy(x => int.Parse(x.Name.Split(new[] { "_SUB" }, StringSplitOptions.None).Last())).ToList();

            /* coordinates */
            var vertexCount = nodes.Sum(x => x.Vertices.Length);
            xml.WriteStartElement("source");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-positions");
            xml.WriteStartElement("float_array");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-positions-array");
            xml.WriteAttributeString("count", vertexCount * 3);
            xml.WriteString(nodes.SelectMany(x => x.Vertices).SelectMany(x => x.Co).JoinToString(" "));
            xml.WriteEndElement(); // float_array

            xml.WriteStartElement("technique_common");
            xml.WriteStartElement("accessor");
            xml.WriteAttributeStringSafe("source", $"#{name}-mesh-positions-array");
            xml.WriteAttributeString("count", vertexCount);
            xml.WriteAttributeString("stride", 3);

            xml.WriteElement("param",
                    "name", "X",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "Y",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "Z",
                    "type", "float");

            xml.WriteEndElement(); // accessor
            xml.WriteEndElement(); // technique_common
            xml.WriteEndElement(); // source

            /* normals */
            xml.WriteStartElement("source");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-normals");
            xml.WriteStartElement("float_array");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-normals-array");
            xml.WriteAttributeString("count", vertexCount * 3);
            xml.WriteString(nodes.SelectMany(x => x.Vertices).SelectMany(x => x.Normal).JoinToString(" "));
            xml.WriteEndElement(); // float_array

            xml.WriteStartElement("technique_common");
            xml.WriteStartElement("accessor");
            xml.WriteAttributeStringSafe("source", $"#{name}-mesh-normals-array");
            xml.WriteAttributeString("count", vertexCount);
            xml.WriteAttributeString("stride", "3");
            
            xml.WriteElement("param",
                    "name", "X",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "Y",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "Z",
                    "type", "float");

            xml.WriteEndElement(); // accessor
            xml.WriteEndElement(); // technique_common
            xml.WriteEndElement(); // source

            /* uv */
            xml.WriteStartElement("source");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-map-0");
            xml.WriteStartElement("float_array");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-map-0-array");
            xml.WriteAttributeString("count", vertexCount * 2);
            xml.WriteString(nodes.SelectMany(x => x.Vertices).SelectMany(x => new[] { x.Uv[0], -x.Uv[1] }).JoinToString(" "));
            xml.WriteEndElement(); // float_array

            xml.WriteStartElement("technique_common");
            xml.WriteStartElement("accessor");
            xml.WriteAttributeStringSafe("source", $"#{name}-mesh-map-0-array");
            xml.WriteAttributeString("count", vertexCount);
            xml.WriteAttributeString("stride", 2);

            xml.WriteElement("param",
                    "name", "S",
                    "type", "float");
            xml.WriteElement("param",
                    "name", "T",
                    "type", "float");

            xml.WriteEndElement(); // accessor
            xml.WriteEndElement(); // technique_common
            xml.WriteEndElement(); // source

            /* vertices */
            xml.WriteStartElement("vertices");
            xml.WriteAttributeStringSafe("id", $"{name}-mesh-vertices");
            xml.WriteElement("input",
                    "semantic", "POSITION",
//.........这里部分代码省略.........

        public override void SerializeContent(XmlWriter writer)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(writer, "writer");

            writer.WriteAttributeString(NamePropertyName, this.Name);
            writer.WriteAttributeIfNotEmpty(TypeNamePropertyName, this.TypeName);
            if (this.LifetimeIsPresent())
            {
                writer.WriteElement("lifetime", this.Lifetime.SerializeContent);
            }
            foreach (var injectionElement in this.Injection)
            {
                writer.WriteElement(injectionElement.ElementName, injectionElement.SerializeContent);
            }
        }

        public override void SerializeContent(XmlWriter writer)
        {
            Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(writer, "writer");

            writer.WriteAttributeString(NamePropertyName, this.Name);
            foreach (var param in this.Parameters)
            {
                writer.WriteElement("param", param.SerializeContent);
            }
        }

        /// <summary>
        /// Write the contents of this element to the given <see cref="XmlWriter"/>.
        /// </summary>
        /// <remarks>The caller of this method has already written the start element tag before
        /// calling this method, so deriving classes only need to write the element content, not
        /// the start or end tags.</remarks>
        /// <param name="writer">Writer to send XML content to.</param>
        public override void SerializeContent(XmlWriter writer)
        {
            writer.WriteAttributeString(TypePropertyName, TypeName);
            writer.WriteAttributeIfNotEmpty(MapToPropertyName, MapToName)
                .WriteAttributeIfNotEmpty(NamePropertyName, Name);

            if(!string.IsNullOrEmpty(Lifetime.TypeName))
            {
                writer.WriteElement("lifetime", Lifetime.SerializeContent);
            }

            SerializeInjectionMembers(writer);
        }