Can this foreach loop be improved? [closed]

Question

Can the below foreach loop be improved? Since I use the same method twice, maybe use continue or break?

int? index = null;
int count = 0;
foreach (Break b in breaks)
{
    if (index.HasValue)
    {
        if (index == count)
            b.Remove();
    }
    else
    {
        b.Remove();
    }
    count++;
}

So I turned it into this:

foreach (Break b in breaks)
{
    if ((index.HasValue && index == count) || !index.HasValue)
    {
        b.Remove();
    }
    count++;
}

Which is the same. Any other optimizations possible?

Answer 1

How about removing the loop at all like:

if (!index.HasValue)
{
     breaks.Clear();
}
else
{
     breaks.RemoveAt((int)index);
}

if you want/need to keep the loop, i would change your second way like:

foreach (Break b in breaks)
{
    if (!index.HasValue || index == count)
    {
        b.Remove();
    }
    count++;
}

Answer 2

Leaving aside the question of why you have index in the first place, you don't need to check for nullity before you use a comparison operator. If you have

int x = whatever;
int? y = whatever;
bool b = x == y;

Then b will be true if y has a value equal to x and false otherwise. You don't have to say something like:

bool b = y.HasValue ? x == y.Value : false;

The compiler will generate that code on your behalf. This feature is called lifting to nullable and it applies to most of the operators in C#.

If the subject of how the compiler analyzes and generates code for lifted operators interests you, I wrote a long series of articles explaining it in detail. See

http://ericlippert.com/2012/12/20/nullable-micro-optimizations-part-one/