ArrayList.Conta ins() slower in NET 2.0 ?

[Robert Hooker]

We are moving to .NET2.0 - and have noticed that .Contains() seems to be
around 20% slower under NET2, compared to NET1.1.

This code shows the issue:
static void Main(string[] args)
{
System.Collecti ons.ArrayList list = new System.Collecti ons.ArrayList() ;

//Setup code
//
//Add 10000 objects to a collection.
//Don't care what type the object is for the purposes of this
demonstration
for (int i=0; i<100000; i++)
{
list.Add(new EventArgs());
}
//We are going to find this object (intentially right at the end of the
list)
object objectToFind = list[99998];
//
// End setup code

// Timing code
//
long startT = Environment.Tic kCount;
//Find the object 1111 times in the collection
for (int j=0;j<1111;j++)
{
bool objectInList = list.Contains(o bjectToFind);
}
System.Console. WriteLine("Cont ains took "+(Environment. TickCount-startT)+"
(ms)");
System.Console. ReadLine();
}

Under NET1.1 I consistently get times in the order of 20% quicker than the
same code under NET2.

Has anyone else noticed this? Is there a way I can avoid whatever new code
is being executed in the bowels of the framework?
Thanks
Rob

[Robert Hooker]

Strangely enough - List<T"Contains " is measureably SLOWER (about 10%
slower) than ArrayList's "Contains".
Sigh...

"Chris Nahr" <ch************ @kynosarges.dew rote in message
news:5s******** *************** *********@4ax.c om...

Rob, have you tried substituting List<Tfor ArrayList? Perhaps the
implementation of that collection is a bit faster.

On Thu, 14 Sep 2006 10:09:12 -0600, "Robert Hooker"
<rh*****@noemai l.noemailwrote:

>>Thanks all - for you replies. I'm happy enough that the 15%-20% slow-down
is
at least experienced by others and its not me on crack.

Collectivel y, your replies have given me a few hints as to ways to improve
things. (Avoid .Contains were we can, and where we can't, I'll investigate
other Comparers)

Thanks again
Rob

--
http://www.kynosarges.de

[Chris Nahr]

Sorry about that, I should have checked the implementations first...

The algorithms look identical in Reflector but List<T>.Contain s uses
an EqualityCompare r<Tto check for identical elements while
ArrayList.Conta ins calls the usual Equals method. I suppose that
might account for the difference.

On Mon, 18 Sep 2006 14:32:11 -0600, "Robert Hooker"
<rh*****@noemai l.noemailwrote:

>Strangely enough - List<T"Contains " is measureably SLOWER (about 10%
slower) than ArrayList's "Contains".
Sigh...

--
http://www.kynosarges.de

[Ben Voigt]

"William Stacey [MVP]" <wi************ @gmail.comwrote in message
news:%2******** ********@TK2MSF TNGP02.phx.gbl. ..

Looks like about the only change is an additional null test in the loop.
Hard to believe a single test would account for 20%, but maybe.
I think this fixes a bug so it is needed code.

There is definitely an unneeded test for null in the second loop in
ArrayList.Conta ins(item)
Equals is required to be commutative
(http://msdn2.microsoft.com/en-us/library/ms173147.aspx), so one can easily
call item.Equals since item has already been found to be non-null, instead
of on each array element, especially since Equals is required to test its
argument for null anyway.

Furthermore, it seems that List<T>.FindInd ex(delegate (T x) { return
item.Equals(x); }) should be faster than List<T>.Contain s(item) for the same
reason.

>
--
William Stacey [MVP]

"Robert Hooker" <rh*****@noemai l.noemailwrote in message
news:ee******** ******@TK2MSFTN GP05.phx.gbl...
| We are moving to .NET2.0 - and have noticed that .Contains() seems to be
| around 20% slower under NET2, compared to NET1.1.
|
| This code shows the issue:
| static void Main(string[] args)
| {
| System.Collecti ons.ArrayList list = new
System.Collecti ons.ArrayList() ;
|
| //Setup code
| //
| //Add 10000 objects to a collection.
| //Don't care what type the object is for the purposes of this
| demonstration
| for (int i=0; i<100000; i++)
| {
| list.Add(new EventArgs());
| }
| //We are going to find this object (intentially right at the end of the
| list)
| object objectToFind = list[99998];
| //
| // End setup code
|
| // Timing code
| //
| long startT = Environment.Tic kCount;
| //Find the object 1111 times in the collection
| for (int j=0;j<1111;j++)
| {
| bool objectInList = list.Contains(o bjectToFind);
| }
| System.Console. WriteLine("Cont ains took
"+(Environment. TickCount-startT)+"
| (ms)");
| System.Console. ReadLine();
| }
|
| Under NET1.1 I consistently get times in the order of 20% quicker than
the
| same code under NET2.
|
| Has anyone else noticed this? Is there a way I can avoid whatever new
code
| is being executed in the bowels of the framework?
| Thanks
| Rob
|
|
|