Giving my +1 to Iván Pérez Gómez and providing some code here to support his answer:

Add the required json.net namespace to the root node:

private static void AddJsonNetRootAttribute(XmlDocument xmlD)
    {
        XmlAttribute jsonNS = xmlD.CreateAttribute("xmlns", "json", "http://www.w3.org/2000/xmlns/");
        jsonNS.Value = "http://james.newtonking.com/projects/json";

        xmlD.DocumentElement.SetAttributeNode(jsonNS);
    }

And to add json:Array attribute to elements found by xpath:

private static void AddJsonArrayAttributesForXPath(string xpath, XmlDocument doc)
    {
        var elements = doc.SelectNodes(xpath);



        foreach (var element in elements)
        {
            var el = element as XmlElement;

            if (el != null)
            {

                var jsonArray = doc.CreateAttribute("json", "Array", "http://james.newtonking.com/projects/json");
                jsonArray.Value = "true";
                el.SetAttributeNode(jsonArray);
            }
        }
    }

Here is a sample of a single child node as a json array:

In case it helps anyone, further to meda's reply. Here's how you make this work with XElement rather than xmlTextWriter and XDocument

XNamespace ns = "http://james.newtonking.com/projects/json";
var items = new XElement("items",new XAttribute(XNamespace.Xmlns+"json",ns));

   items.Add(new XElement("item",new XAttribute(ns+"Array",true),
                        new XElement("name", "name"),
                        new XElement("Detail", "detail")));

then to convert it

 XmlDocument doc = new XmlDocument();
            doc.LoadXml(items.ToString());
            var converted JsonConvert.SerializeXmlNode(doc);

It shouldn't impact too much in your performance if you create an array of objects in your code from your XML doc (you need to know the content structure and use POCO objects) and then serialize that list with json. Makes it sense in your case?

So I figured out what I was doing wrong if anyone is interested. When I was creating the attribute:

XmlAttribute attr = originalDoc.CreateAttribute(@"json:Array");

I was trying to name it with my prefix. The proper way to do this is to pass in the prefix, name and namespace as the parameters.

XmlAttribute attr = doc.CreateAttribute("json", "Array", "http://james.newtonking.com/projects/json");

The XMl to JSon loses all the information of any attributes that have ':' (colon) in their name. Which is why 'id' get serialised to @id but 'xmlns:json' is lost in translation.

If you have access to the raw XML then I will suggest you replace the colons(:) by hyphens(-). In this case, the XML will be:

<person xmlns-json='http://james.newtonking.com/projects/json' id='1'>
    <name>Alan</name>
    <url>http://www.google.com</url>
    <role json-Array='true'>Admin</role>
</person>

I have checked that this serialises and de-serialises to the same input and output.

var xmlString = @"<person xmlns-json='http://james.newtonking.com/projects/json' id='1'><name>Alan</name><url>http://www.google.com</url><role json-Array='true'>Admin</role></person>";
var xml = new XmlDocument();
xml.LoadXml(xmlString);

var json = JsonConvert.SerializeXmlNode(xml);

var xmlDeserialized = JsonConvert.DeserializeXmlNode(json);
xmlDeserialized.Should().NotBeNull();
xmlDeserialized.ShouldBeEquivalentTo(xml); //All good

Yes, you can do it (I do) but Be aware of some paradoxes when converting, and handle appropriately. You cannot automatically conform to all interface possibilities, and there is limited built-in support in controlling the conversion- many JSON structures and values cannot automatically be converted both ways. Keep in mind I am using the default settings with Newtonsoft JSON library and MS XML library, so your mileage may vary:

XML -> JSON

1. All data becomes string data (for example you will always get "false" not false or "0" not 0) Obviously JavaScript treats these differently in certain cases.
2. Children elements can become nested-object {} OR nested-array [ {} {} ...] depending if there is only one or more than one XML child-element. You would consume these two differently in JavaScript, etc. Different examples of XML conforming to the same schema can produce actually different JSON structures this way. You can add the attribute json:Array='true' to your element to workaround this in some (but not necessarily all) cases.
3. Your XML must be fairly well-formed, I have noticed it doesn't need to perfectly conform to W3C standard, but 1. you must have a root element and 2. you cannot start element names with numbers are two of the enforced XML standards I have found when using Newtonsoft and MS libraries.
4. In older versions, Blank elements do not convert to JSON. They are ignored. A blank element does not become "element":null

A new update changes how null can be handled (Thanks to Jon Story for pointing it out): https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_NullValueHandling.htm

JSON -> XML

1. You need a top level object that will convert to a root XML element or the parser will fail.
2. Your object names cannot start with a number, as they cannot be converted to elements (XML is technically even more strict than this) but I can 'get away' with breaking some of the other element naming rules.

Please feel free to mention any other issues you have noticed, I have developed my own custom routines for preparing and cleaning the strings as I convert back and forth. Your situation may or may not call for prep/cleanup. As StaxMan mentions, your situation may actually require that you convert between objects...this could entail appropriate interfaces and a bunch of case statements/etc to handle the caveats I mention above.

If you're using FXP (fast-xml-parser), you can use folloing configuration to avoid array index as tag name

const parser = new j2xParser({
    rootNodeName: "car"
});
const result = parser.parse(cars);

FXP version must be > 3.21.0

With Cinchoo ETL - an open source library, you can do the Xml to Json easily with few lines of code

string json = @"
[
    {
        ""car"": {
            ""features"": [{
                ""code"": ""1""
            }, {
                ""code"": ""2""
            }]
        }
    },
    {
        ""car"": {
            ""features"": [{
                ""code"": ""3""
            }, {
                ""code"": ""2""
            }]
        }
    }
]";
StringBuilder sb = new StringBuilder();
using (var p = ChoJSONReader.LoadText(json))
{
    using (var w = new ChoXmlWriter(sb)
        .Configure(c => c.RootName = "cars")
        //.Configure(c => c.IgnoreRootName = true)
        .Configure(c => c.IgnoreNodeName = true)
        )
    {
        w.Write(p);
    }
}
Console.WriteLine(sb.ToString());

Output:

<cars>
  <car>
    <features>
      <feature>
        <code>1</code>
      </feature>
      <feature>
        <code>2</code>
      </feature>
    </features>
  </car>
  <car>
    <features>
      <feature>
        <code>3</code>
      </feature>
      <feature>
        <code>2</code>
      </feature>
    </features>
  </car>
</cars>

Checkout CodeProject article for some additional help.

Disclaimer: I'm the author of this library.

Answering your 1st question: What is the proper way to represent an array in xml?

Please refere to: http://www.w3.org/2005/07/xml-schema-patterns.html#Vector

Using xml-js lib

import { json2xml } from "xml-js";

const input = {
  contact: {
    name: `John & cia "example"`
  }
};
const xml = json2xml(input, {
  compact: true
});

// <contact><name>John &amp; cia \"example\"</name></contact>

https://codesandbox.io/s/xml-json-forked-zgit4?file=/src/index.js:97-103

:)