First of all, loop unrolling is a micro-optimization and won't get to a lot of benefit. Don't bother until it's absolutely needed.
More importantly, the way to optimize code is more about the data structures and algorithms used, not how fast you can iterate through a collection.
In your particular example, you are effectively doing this..
for (int p = 0; p < particle.Count; p++)
{
for (int t = 0; t < Map.tiles.Count; t++)
{
CheckCollitions(Map.tile[t], particle[p]);
}
}
Nested loops like this indicate an O(n^2) complexity and are a sure sign of potential performance issues.
Typically when you are working with collision detection you can optimize the code by reducing the number of objects that could collide based on things you already know.
For example, I assume tiles don't move around and are laid out in a uniform grid. I can also assume particles are very small.
Let's say you store tile data in a 2 dimensional array.
var tiles = new int[32,32];
A value of 0 means no tile, and a value of 1 (or > 0) means the tile is solid. You also know that when tiles are rendered on the screen they are 64x64 pixels.
This means, you can do a basic collision test with any tile very quickly using simple math..
for (int p = 0; p < particle.Count; p++)
{
var tileWidth = 64;
var tileHeight = 64;
var particlePosition = particle[p].Position;
var tx = particlePosition.X / tileWidth;
var ty = particlePosition.Y / tileHeight;
var tile = tiles[tx, ty];
if(tile == 0)
{
// no collision
}
else
{
// collision detected
}
}
At this point, you know exactly which tile in the array the particle position falls into and removed the inner loop (effectively reducing it to an O(n) complexity). Obviously, you'll also need to be careful not to check outside the bounds of the array and there may be some other details to deal with if your particles are larger than a single pixel, but you get the idea.