How to convert JSON to XML with added custom tag in C#

To change format of your input you should first deserialize JSON to matching model, then you can use System.Xml.Linq to export nodes in the order and structure whatever you desire.

Model model = JsonConvert.DeserializeObject<model>(jsonString);
var xml = new XElement("properties", 
               new XElement("property",
                  new XElement("id", model.Id),
                  new XElement("name", model.Name) /*and so on*/));

It looks like a lot of writing, but you can do whatever you want with the XML really. You can prepare methods to process model and adjust it, but it is up to your requirements.

You can also create another model with structure corresponding to that of xml file, which you will then have to fill with data from original node, but this looks like a lot of unnecessary work. I personally will use System.Xml.Linq for such task.

Here's how I solved it. First I created C# classes for the corresponding JSON/XML elements:

    [XmlRoot("tag")]
    [JsonObject(Title = "tag")]
    public class Tag
    {
        [XmlElement("id")] public string Id { get; set; }
        [XmlElement("externalGuid")] public string ExternalGuid{ get; set; }
        [XmlElement("tagNumber")] public string TagNumber { get; set; }
        [XmlElement("project")] public Project Project { get; set; }
        [XmlArray("properties")] public List<Property> Properties { get; set; }
    }

    [XmlType("property")]
    public class Property
    {
        [XmlElement("id")] public string Id { get; set; }
        [XmlElement("name")] public string Name { get; set; }
        [XmlElement("value")] public string Value { get; set; }
        [XmlElement("status")] public Status Status { get; set; }
    }

    public class Status
    {
        [XmlElement("id")] public string Id { get; set; }
        [XmlElement("name")] public string Name { get; set; }
        [XmlElement("code")] public int Code { get; set; }
    }

    public class Project
    {
        [XmlElement("id")] public string Id { get; set; }
        [XmlElement("projectName")] public string ProjectName { get; set; }
        [XmlElement("projectId")] public string ProjectId { get; set; }
    }

Then I implemented a custom Json to XML converter:

        public static string TransformJsonToXml<T>(string json)
        {
            var jsonObjectAttribute = typeof(T).GetCustomAttribute(typeof(JsonObjectAttribute)) as JsonObjectAttribute;
            JObject root = JObject.Parse(json);
            var data = root[jsonObjectAttribute.Title];

            var obj = JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(data));

            var serializer = new XmlSerializer(typeof(T));
            var stringWriter = new StringWriter();
            using var xmlWriter = XmlWriter.Create(stringWriter);
            var xmlSerializerNamespaces = new XmlSerializerNamespaces();
            xmlSerializerNamespaces.Add("","");
            serializer.Serialize(xmlWriter, obj, xmlSerializerNamespaces);
            return stringWriter.ToString();
        }

Now transforming the JSON to XML is simply: var xml = TransformJsonToXml<Tag>(jsonInput);

You could write a custom XmlNodeConverter that would insert a parent element if the current element is an array. For example,

public class ArrayXmlNodeConverter : XmlNodeConverter
{
    public readonly string _arrayRootName;

    public ArrayXmlNodeConverter(string rootElement,string arrayRootName)
    {
        (DeserializeRootElementName,_arrayRootName) = (rootElement,arrayRootName);
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var token = JObject.Load(reader);
        ChangeArrayElementRoot(token);
        reader = token.CreateReader();
        reader.Read();
        return base.ReadJson(reader, objectType, existingValue, serializer);
    }

    private void ChangeArrayElementRoot(JToken token)
    {
        if (token.Type == JTokenType.Array)
        {
            var arrayHolder = new JObject { { _arrayRootName, token } };
            token.Replace(arrayHolder);
        }
        else
        {
            foreach (var childToken in token)
            {
                ChangeArrayElementRoot(childToken);
            }
        }
    }
}

Now you could use as

var xml = (XmlDocument)JsonConvert.DeserializeObject(jsonString,
                   typeof(XmlDocument), 
                   new ArrayXmlNodeConverter("tag","Property"));

Demo Code