about generics

[Tony Johansson]

Hello!

I have read that in practice, casting proved to be several times faster than
using a generic.

So the main reason to use generics is not that the performance is better
because that's not the case.
The only reason is that it's type-safe.

I must ask if anyone has made any significant performance improvement using
generics ?

//Tony

 

[Jon Skeet [C# MVP]]

I have read that in practice, casting proved to be several times
faster than using a generic.

Where have you read that? It's such a vague statement that it can't
really be commented on without a specific example.

So the main reason to use generics is not that the performance is better
because that's not the case.

Yes it is - particularly with value types.

The only reason is that it's type-safe.

It's also far more expressive in terms of API, cleaner to use, and
avoids boxing/unboxing.

I must ask if anyone has made any significant performance improvement using
generics ?

Anyone who uses value types in a collection for a start...

 

[Marc Gravell]

Generics also avoid boxing, which can (in some scenarios) be an
overhead. But generics avoid the need to cast, so can improve
performance.

In some scenarios use generics extensively to optimise some reflection
operations, along the same lines as Jon's blog here:

http://msmvps.com/blogs/jon_skeet/a...g-reflection-fly-and-exploring-delegates.aspx

Marc

 

[Tony Johansson]

Hello!

This is what Tony Northrup MCSE CISSP and Microsoft MVP says.
"I haven't been able to reproduce the performance benefits of generics;
however,
according to Microsoft, generics are faster than using casting. In practice,
casting proved to be several times faster than
using a generic. However, you probably won't notice performance difference
in your application.
(My Test over 100 000 iterations took only a few seconds). So you should
still use generics because they are type-safe."

//Tony

 

[Jon Skeet [C# MVP]]

This is what Tony Northrup MCSE CISSP and Microsoft MVP says. "I
haven't been able to reproduce the performance benefits of generics;
however, according to Microsoft, generics are faster than using
casting. In practice, casting proved to be several times faster than
using a generic. However, you probably won't notice performance
difference in your application. (My Test over 100 000 iterations took
only a few seconds). So you should still use generics because they
are type-safe."

That's pretty meaningless as he doesn't say what he's doing. Is there
really no code provided or even a description of his test?

 

[Tony Johansson]

Hello!

No

//Tony

That's pretty meaningless as he doesn't say what he's doing. Is there
really no code provided or even a description of his test?

--
Jon Skeet - <[email protected]>
Web site: http://www.pobox.com/~skeet
Blog: http://www.msmvps.com/jon.skeet
C# in Depth: http://csharpindepth.com

 

[Ignacio Machin ( .NET/ C# MVP )]

Hello!

I have read that in practice, casting proved to be several times faster than
using a generic.

What if you do not know (or care) to what to cast to?
also I bet you anything that it will nt apply to a value type, say
Int32

So the main reason to use generics is not that the performance is better
because that's not the case.
The only reason is that it's type-safe.

As I said a cast with a value type is a slow operation, you have to
unbox it.

 

[Ignacio Machin ( .NET/ C# MVP )]

Hello!

This is what Tony Northrup MCSE CISSP and Microsoft MVP says.
"I haven't been able to reproduce the performance benefits of generics;
however,
according to Microsoft, generics are faster than using casting. In practice,
casting proved to be several times faster than
using a generic. However, you probably won't notice performance difference
in your application.
(My Test over 100 000 iterations took only a few seconds). So you should
still use generics because they are type-safe."

With generics you do not have to cast. So instead of taking into doubt
the "performance" of generics the above statement is saying that
casting is a very low cost operation

 

[Jon Skeet [C# MVP]]

Hello!

No

Okay, well I'm happy to write the test instead:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

class Test
{
const int Iterations = 100;
const int Size = 10000000;

static void Main()
{
// Comment out the one you don't want to use
// ArrayList list = new ArrayList(Size);
List<byte> list = new List<byte>(Size);

Stopwatch sw = Stopwatch.StartNew();
for (int i=0; i < Size; i++)
{
list.Add((byte) i);
}
int total = 0;
for (int i=0; i < Iterations; i++)
{
foreach (byte b in list)
{
total += b;
}
}
sw.Stop();
Console.WriteLine("Total = {0}", total);
Console.WriteLine("Time = {0}ms", sw.ElapsedMilliseconds);
}
}

Results:

For List<T>: around 8 seconds
For ArrayList: around 22 seconds

Oh, and originally I had Size ten times larger, but that caused
swapping with ArrayList - but not with List<T>.