I split the outer for loop into two while loops. The first while loop deals with all values of i < = maxSquareRoot. This way you can remove the test before the inner for loop of your original code.

The second while loop then just harvests the flagged primes remaining in the sieve.

In addition I calculated i2 = 2 x i outside the for loop rather than recalculate every time we go around the inner for loops.

///
/// Use the Sieve of Eratosthenes to compile and return a list of prime numbers up to max
/// Inspired by Josh Bush
/// http://digitalbush.com/2010/02/26/sieve-of-eratosthenes-in-csharp/comment-page-1/#comment-3261
///
/// Maximum prime number in the list.
/// List of prime numbers in the range [2..max].
static public IList CachePrimesE( int max )
{
IList vals = new List( (int)(max / (Math.Log( max ) – 1.08366)) ); // Create the list to hold the primes
int maxSquareRoot = (int)Math.Sqrt( max );
BitArray eliminated = new BitArray( max + 2 ); // Create the bit array for our sieve

// Add the first two prime numbers
vals.Add( 2 );
vals.Add( 3 );

// All primes greater than 3 can be written in the form 6k +/- 1.
// If we make i = 6k-1 then we process i and i + 2 through each iteration of the while loops!
int i = 5;
while(i <= maxSquareRoot)
{
// Process i
if ( !eliminated[i] )
{
for ( int j = i * i, i2 = i + i; j <= max; j += i2 )
eliminated[j] = true;
vals.Add( (uint)i ); // Add i to the prime number list
}

// Process i + 2
i += 2;
if ( !eliminated[i] )
{
for ( int j = i * i, i2 = i + i; j = SQR(max) so simply harvest the remaining primes in the sieve
while(i <= max)
{
if ( !eliminated[i] )
vals.Add( (uint)i ); // Add i to the prime number list
i += 2;
if ( !eliminated[i] )
vals.Add( (uint)i ); // Add i to the prime number list
i += 4;
}
Console.WriteLine( vals.Count );
return vals;
}

Nice bit of coding! Taking up the challenge I added another optimisation that you might want to play around with. On my PC it went about 20% faster caching all primes <= 100M.

Another area I looked at was the maxSquareRoot assignment which I believe compiles to a double. Any later comparisons will take that lil' bit longer to process than if you use an int.

Here is the revised code:

static public IList CachePrimesE( int max )
{
List vals = new List( (int)(max / (Math.Log( max ) – 1.08366)) );
int maxSquareRoot = (int)Math.Sqrt( max );
BitArray eliminated = new BitArray( max + 2 );

// Add the first prime number
vals.Add( 2 );
vals.Add( 3 );
vals.Add( 5 );

// All primes greater than 3 can be written in the form 6k +/- 1. If we make i = 6k-1 then we process i and i + 2!
for ( int i = 5; i <= max; i += 4 )
{
// Process i
if ( !eliminated[i] )
{
if ( i < maxSquareRoot )
{
for ( int j = i * i; j <= max; j += 2 * i )
eliminated[j] = true;
}
vals.Add( (uint)i );
}

// Process i + 2
i += 2;
if ( !eliminated[i] )
{
if ( i < maxSquareRoot )
{
for ( int j = i * i; j <= max; j += 2 * i )
eliminated[j] = true;
}
vals.Add( (uint)i );
}

}

return vals;
}

You may want to test more thoroughly before you stick your foot in your mouth. Your algorithm was slightly faster with smaller values of ‘target’, but as that number grew, your ‘superior’ version was slower. This was tested on multiple boxes by a few people.

How do you like ‘dem apples?

public static List Sieve2(int target)
{
var isPrime = new BitArray(target, true);
var primesList = new List { 2 };
var squareRoot = Math.Sqrt(target);

for (int candidate = 3; candidate < target; candidate +=2)
{
if (!isPrime[candidate]) continue;

if (candidate < squareRoot)
{
for (int multiple = candidate*candidate; multiple < target; multiple += 2*candidate)
{
isPrime[multiple] = false;
}
}
primesList.Add(candidate);
}
return primesList;
}