The most efficient approach is a string array, but you can't dynamically
resize arrays so you either need to know the size in advance, or you need to
use some sort of wrapper class that allocates and coordinates arrays of a
known size, adding a new array of some reasonable number of elements (100K
or whatever is appropriate for you scenario) as needed.

That's a lot of work, though, and violates the KISS principle.  So in the
current CLR (1.1) you would use an ArrayList.  An ArrayList can grow
dynamically, but it only holds the System.Object type and so you have
casting overhead to get the strings back out.  Even so, you ought to give it
a whirl and see what the real world performance will be before deciding
against it.

The ideal in CLR 2.0 would be a generic List<string>.  This gives you
effectively a dynamically sizeable strongly typed string array.  But
production bits are still a few months away.

Another possibility if the string size doesn't vary much is to determine the
max string size and just put everything into a great big unsafe buffer of
MaxSize * NumberOfStrings within a wrapper class that has an indexer that
can return strings by index using pointers.  I've never gone there, but it's
certainly possible to do.  I would only look into this as a last resort
though.  ArrayList is remarkably performant, despite the casting.

Another thing to look at alongside all this is the often-overlooked
technique of string interning.  Your strings may have a lot of repeating
data -- for example, the city, state and zip in addresses often repeat;
there are finite numbers of first names.  You can sometimes cut memory
consumption by 90% or so by using the string interning pool, so that you
have one copy in memory of each unique string value.  See the docs on
String.Intern() for details.  In my experience this will slow down loading
quite a bit but it also saves a great deal of memory for other uses and I
haven't seen a noticeable performance penalty for access once all the
strings are loaded.  The nice thing about interning is it's not an
all-or-nothing thing; if you know something about your data you can use it
selectively where it will do you the most good while minimizing the
performance penalty.  Returning to the name & address example, you might
intern city and state, probably zip (especially if the data is from one
locale), maybe first or even last name, but generally there wouldn't be much
point in interning address or phone number.

--Bob

If you are concating huge strings then instead of using
for( int i = 0 ; i < arraylist.count; i++)
   teststring  += "this is a test" + "\n";

use
StringBuilder teststring = new StringBuilder(specify your size);
for( int i = 0 ; i < arraylist.count; i++)
   teststring.Append("this is a test" + "\n");
Later is 1000 times faster...