That's exactly what I'd expect when taking a very shallow copy (and
MemberwiseClone is as shallow as it gets) of a mutable collection.

You'd probably see some interesting behaviour after adding enough
items to one ArrayList to cause a resize - suddenly they'd be
independent again.

Basically cloning anything non-trivial is fraught with problems.
Another argument in favour of immutable collections :) (See Eric
Lippert's blog for details.)

Jon

Had to struggle to remember...

First - we were talking about arrays, not ArrayList - there is a
*huge* difference. To clone an ArrayList you would call Clone() - this
will internally worry about "doing the right thing" i.e. creating a
separate array. However, this can't know about your new type, so you
will need to write Clone yourself, as below.

Second; yes - the question of deep vs shallow copy is one that I
myself commented on:

<quote>
The point I was trying to
make, however, is that if you have a class inside the array, you
might
actually want to clone that too! Or you might not, it depends on the
scenario.</quote>

By default you have a shallow copy; this is expected. If you want a
deep clone you'll have to do it yourself. In 2.0 you could perhaps
insist that the items are cloneable.

By the way, I swapped the public field for a property; you might also
want to avoid using ArrayList if you are in 2.0; generics and things
like List<T>/Collection<T> largely deprecate ArrayList.

First code sample is ArrayList, and makes no pretence at a deep copy.

       public class thinglist : ArrayList
       {
           // Text (1 line in C# 3)
           private string text;
           public string Text
           {
               get { return text; }
               set { text = value; }
           }
           // ctors
           public thinglist()  { }
           private thinglist(ICollection data) : base(data) { }
           // clone
           public override object Clone()
           {
               thinglist clone = new thinglist(this); // copies data
               clone.Text = this.Text;
               return clone;
           }
       }

Second example using generics with a constraint to enforce clonability
of contained items:
(used by NamedCollection<thing> etc)

public class NamedCollection<T> : Collection<T>, ICloneable
   where T : ICloneable
{
   private string text;
   public string Text {
       get { return text; }
       set { text = value; }
   }
   public NamedCollection() { }

   object ICloneable.Clone() { return Clone(); }
   public virtual NamedCollection<T> Clone() {
       NamedCollection<T> clone = new NamedCollection<T>();
       clone.Text = Text;
       foreach (T value in this) {
           clone.Items.Add(value == null ? value : (T)value.Clone());
       }
       return clone;
   }
}

That is because you uses MemberwiseClone() - that would have been fine
for an array (the original topic), but is not really suitable for this
example.