You're talking about the MFC CArray class. That's not the same thing as a
"C++ array". C++ has plain old C arrays, but those don't grow.

No. Array objects are immutable in C# (their contents are not, of course).

Use a List<T> instead. (That's not a linked list, contrary to what you might
think, it's the equivalent of an STL vector.)

List<T> has no way of automatically expanding to a specified index, but it's
easy enough to achieve. Here's an extension method in C# 3 that will achieve
the same as CArray::SetAtGrow:

  public static void SetAtGrow<T>(this List<T> list, int index, T item) {
    if (list.Count > index) return;
    if (list.Capacity < index) list.Capacity = index;
    list.AddRange(Forever(default(T)).Take(index - list.Count));
    list.Add(item);
  }

  public static IEnumerable<T> Forever<T>(T item) {
    while (true) yield return item;
  }

If you're going to do this a lot, you'll want to set .Capacity to a
reasonable value before, to minimize reallocations. If the list you're going
to be creating this way is very sparse, consider using a Dictionary<int, T>
instead.

I'll say. It'll be especially awkward for performance. .Resize() does not
actually resize an array, it creates a brand new one -- the documentation
explains this.

No

Use a List<T> collection.

No they don't.  Certain array templates have that method, but C++ arrays  
themselves don't support that.

Not really, no.  You found Array.Resize(), which is about as close as  
you're going to get with the actual Array class.

If you are specifically needing to expand an array to accomodate a new  
element at some index farther into the index space of the array than just  
the next element after the current end of the array, I think  
Array.Resize() is your best bet.  There's the List<T> class, but it only  
supports dynamic expansion one element at a time.

I suppose if you have a need to do this on a regular basis, you could  
implement your own generic collection class that worked like List<T> but  
which had a settable Count property.  I don't think that'd actually be all  
that hard to write and it would address your specific need.

Pete