Can I resize an array?

[Maxwell2006]

Hi,

I declared an array like this:

string[] scriptArgs = new string[10];

Can I resize the array later in the code?

Thank you,
Max

[Bruce Wood]

> I redesigned an application that stored pixel

values of a camera in an ArrayList (.NET 1.1) of floats. The number of
varies from (320*240, 640*480, and 1024 * 1024). Performing calculations on
these pixel values stored in an ArrayList took many seconds, and sometimes
minutes. I converted the ArrayLists to arrays of floats and the calculations
now only take a couple of seconds.

Yes, but that's exactly my point. You had a slow application, you
determined where the slowdown was, and you optimized that section. My
point is that one shouldn't "optimize" before determining that there is
indeed a problem. In most cases, there won't be. In a few, such as
yours, there will be, and in those cases a change in data structure is
a good idea.

Too many programmers read that "boxing and unboxing are slow" and then
do horrible, tortured things to their code in order to avoid boxing and
unboxing at all costs, when in fact that's unnecessary in most cases.
It's far better to write the code using the data structure that makes
sense given the design, then profile the application, then make
adjustments where necessary, which is just what you did.

The only mistake that the original author of your application made was
that he or she didn't profile it to see if there was a problem area in
the code.

[Jon Skeet [C# MVP]]

rmacias <rm*****@newsgr oup.nospam> wrote:

Even in .NET 1.1, though, boxing and unboxing are rarely so noticeable
that it's worth warping your design if an ArrayList was the "right
choice" from a design standpoint. Always choose the most appropriate
data structure for your design and then profile your app to see if
things like boxing cause you a real performance problem. Adapt your
design only if this is so. Otherwise you get tortured code in the name
of "efficiency " in spots where if you did it the nice (but
"inefficien t") way it would have almost no effect on your program
whatsoever.

I disagree about the performance hit of boxing/unboxing. For a small amount
of elements, there is a performance differents, but it is so small it is not
noticable. However, when you get into the thousands, and larger,
boxing/unboxing is noticable. I redesigned an application that stored pixel
values of a camera in an ArrayList (.NET 1.1) of floats. The number of
varies from (320*240, 640*480, and 1024 * 1024). Performing calculations on
these pixel values stored in an ArrayList took many seconds, and sometimes
minutes. I converted the ArrayLists to arrays of floats and the calculations
now only take a couple of seconds.

It really depends on the application. If you iterate through the array
once, the it doesn't make a difference. However, you have to access the
elements many times and interate through the arrays multiple times, then you
do notice a difference.

That's exactly what Bruce said though: write the code in the most
natural, readable way, then if there are performance problems, change
your app (after profiling) to fix those problems.

For "many times" and "multiple times" to actually make a significant
difference, you're likely to have to access millions of items (or the
same few items millions of times).

Even within the same app, there may be times where it's most
appropriate to use an ArrayList and times where an array would be
better. I totally agree with Bruce though - write the code to be
readable first, and worry about micro-optimisation later.

(One particular feature of your app sounds like you knew at runtime
what the size of the array would be before populating, so there
wouldn't be any need for resizing. When you know the size to start
with, an array usually ends up being easier to work with than an
ArrayList anyway.)

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Jon Skeet [C# MVP]]

Bruce Wood <br*******@cana da.com> wrote:

So far as I know (and I'm often wrong) this is exactly what happens
with an ArrayList. ArrayList uses an array as its backing
implementation, so when you fill your ArrayList it simply allocates
another array and copies the contents from one to the other. I believe
that the size of the backing array doubles on each reallocation.

Of course, I could be completely out to lunch. Anyone know if this is
so?

Spot on.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too