Newtonsoft.Json.Converters.XmlNodeConverter.SerializeNode C# (CSharp) Méthode

    private void SerializeNode(JsonWriter writer, XmlNode node, bool writePropertyName)
    {
      switch (node.NodeType)
      {
        case XmlNodeType.Document:
        case XmlNodeType.DocumentFragment:
          SerializeGroupedNodes(writer, node);
          break;
        case XmlNodeType.Element:
          if (writePropertyName)
            writer.WritePropertyName(node.Name);

          if (ValueAttributes(node.Attributes).Count() == 0 && node.ChildNodes.Count == 1
                  && node.ChildNodes[0].NodeType == XmlNodeType.Text)
          {
            // write elements with a single text child as a name value pair
            writer.WriteValue(node.ChildNodes[0].Value);
          }
          else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty(node.Attributes))
          {
            // empty element
            writer.WriteNull();
          }
          else if (node.ChildNodes.OfType<XmlElement>().Where(x => x.Name.StartsWith("-")).Count() > 1)
          {
            XmlElement constructorValueElement = node.ChildNodes.OfType<XmlElement>().Where(x => x.Name.StartsWith("-")).First();
            string constructorName = constructorValueElement.Name.Substring(1);

            writer.WriteStartConstructor(constructorName);

            for (int i = 0; i < node.ChildNodes.Count; i++)
            {
              SerializeNode(writer, node.ChildNodes[i], false);
            }

            writer.WriteEndConstructor();
          }
          else
          {
            writer.WriteStartObject();

            for (int i = 0; i < node.Attributes.Count; i++)
            {
              SerializeNode(writer, node.Attributes[i], true);
            }

            SerializeGroupedNodes(writer, node);

            writer.WriteEndObject();
          }

          break;
        case XmlNodeType.Comment:
          if (writePropertyName)
            writer.WriteComment(node.Value);
          break;
        case XmlNodeType.Attribute:
        case XmlNodeType.Text:
        case XmlNodeType.CDATA:
        case XmlNodeType.ProcessingInstruction:
        case XmlNodeType.Whitespace:
        case XmlNodeType.SignificantWhitespace:
          if (node.Prefix == "xmlns" && node.Value == JsonNamespaceUri)
            break;
          else if (node.NamespaceURI == JsonNamespaceUri)
            break;

          if (writePropertyName)
            writer.WritePropertyName(GetPropertyName(node));
          writer.WriteValue(node.Value);
          break;
        case XmlNodeType.XmlDeclaration:
          XmlDeclaration declaration = (XmlDeclaration)node;
          writer.WritePropertyName(GetPropertyName(node));
          writer.WriteStartObject();

          if (!string.IsNullOrEmpty(declaration.Version))
          {
            writer.WritePropertyName("@version");
            writer.WriteValue(declaration.Version);
          }
          if (!string.IsNullOrEmpty(declaration.Encoding))
          {
            writer.WritePropertyName("@encoding");
            writer.WriteValue(declaration.Encoding);
          }
          if (!string.IsNullOrEmpty(declaration.Standalone))
          {
            writer.WritePropertyName("@standalone");
            writer.WriteValue(declaration.Standalone);
          }

          writer.WriteEndObject();
          break;
        default:
          throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType);
      }
    }
    #endregion