A list of objects is easier to work with. You can use append, map, filter... All the nice things JS Arrays have which manual indexing doesn't. And there's no way to get out of sync, so that's an entire class of bugs gone.

If you're worried about efficiency:

• Measure (premature optimization is the root of all evil)
• Consider the list of lists trick AIWalker proposed
• Consider an outright binary format
• Make sure gzip is enabled
• Measure (it's worth saying twice)

The first example from your question,

Copyfoos: [
    foo: { ... },
    foo: { ... }
]

is in invalid syntax. You cannot have object properties inside a plain array.

The second example from your question,

Copyfoos: [
    { ... },
    { ... }
]

is right although it is not strict JSON. It's a relaxed form of JSON wherein quotes in string keys are omitted.

Following is the correct one when you want to obey strict JSON:

Copy"foos": [
    { ... },
    { ... }
]

This "Mastering JSON" tutorial by Patrick Hunlock, may help to learn about JSON and this site may help to validate JSON.

The

return Json()

will actually serialize the object it takes as a parameter. As you are passing in a json string, it's getting double encoded. Create an anonymous object with a property named People, then serialize it. so you can:

return Content(JsonConvert.SerializeObject(new {People=PersonList}))

or

return Json(new {People=PersonList});

Don't try to represent sets in JSON. Do it when parsing the data instead.

Your JSON data should have a schema which specifies which fields should be treated as a set, or you may have a metadata embedded in the JSON data itself that describes when a list should be treated as a set (e.g. {"houses": {"_type": "set", "value": [...]}}) or with a naming convention.

Note that according to JSON standard, a JSON object can have duplicate keys. ECMA-404 wordings:

Objects

[...] The JSON syntax does not impose any restrictions on the strings used as names, does not require that name strings be unique, and does not assign any significance to the ordering of name/value pairs. These are all semantic considerations that may be defined by JSON processors or in specifications defining specific uses of JSON for data interchange.

AFAICD, nothing in the spec forbids non unique names, and there are many JSON parser implementations that can parse non unique object names. RFC 7159 discourages non unique names for interoperability, but specifically don't forbid it either, and goes on to list how various parsers have been seen handling non unique object names.

And ECMA 404 also doesn't require that array ordering be preserved:

Arrays

The JSON syntax does not define any specific meaning to the ordering of the values. However, the JSON array structure is often used in situations where there is some semantics to the ordering.

This wording allows applications to use arrays to represent sets if they so choose.