In JSON.NET IList<T> serialization, why are T[] and List<T> treated differently
I have a DTO with a member `IList<A> Things { get; set; }`. Assume I have two classes, `B` and `C` which derive from A. I want to preserve type information in this polymorphic list, so I specify `TypeNameHandling = TypeNameHandling.Auto` in my serializer settings. If I set `Things` to an array (which Implements `IList<A>`) this way

    Things = new A[] { new B(), new C() }

Then I get a serialized string

    {"Things":{"$type":"A", "$values":[{"$type":"B"}, {"$type":"C"}]}}

If I assign an actual `List<A>` like this

    Things = new List<A> { new B(), new C() }

Then I get a serialized string

    {"Things":[{"$type":"B"}, {"$type":"C"}]}

This latter one is much more usable by 3rd party clients, as it turns a list-like thing into an actual array, instead of a wrapped array. Unfortunately this nice behavior can't be guaranteed simply through defining the DTO correctly. By defining the collection as `IList<A>`, I still can't control whether someone will assign a `A[]` or `List<A>` (or even something else).

As it turns out, if I define my DTO like `A[] Things { get; set; }`, then the serialization acts as I expect. So perhaps the correct answer to this question is "don't do that!" But it strikes me as odd that a concrete `A[]` type would be serialized differently depending on whether one looked at it as a `A[]` or an `IList<T>`. 
In JSON.NET IList<T> serialization, why are T[] and List<T> treated differently
===

I have a DTO with a member `IList<A> Things { get; set; }`. Assume I have two classes, `B` and `C` which derive from A. I want to preserve type information in this polymorphic list, so I specify `TypeNameHandling = TypeNameHandling.Auto` in my serializer settings. If I set `Things` to an array (which Implements `IList<A>`) this way

    Things = new A[] { new B(), new C() }

Then I get a serialized string

    {"Things":{"$type":"A", "$values":[{"$type":"B"}, {"$type":"C"}]}}

If I assign an actual `List<A>` like this

    Things = new List<A> { new B(), new C() }

Then I get a serialized string

    {"Things":[{"$type":"B"}, {"$type":"C"}]}

This latter one is much more usable by 3rd party clients, as it turns a list-like thing into an actual array, instead of a wrapped array. Unfortunately this nice behavior can't be guaranteed simply through defining the DTO correctly. By defining the collection as `IList<A>`, I still can't control whether someone will assign a `A[]` or `List<A>` (or even something else).

As it turns out, if I define my DTO like `A[] Things { get; set; }`, then the serialization acts as I expect. So perhaps the correct answer to this question is "don't do that!" But it strikes me as odd that a concrete `A[]` type would be serialized differently depending on whether one looked at it as a `A[]` or an `IList<T>`. 