How to break out of 2 loops without a flag variable in C#?

As a trivial example lets say I have the following grid and I am looking for a particular cells value. When found I no longer need to process the loops.

foreach(DataGridViewRow row in grid.Rows)
{
    foreach(DataGridViewCell cell in row.Cells)
    {
        if(cell.Value == myValue)
        {
            //Do Something useful
            //break out of both foreach loops.
        }
    }
}

How is this done in C#. In Java I could use a label to name the outermost loop, and then break that loop, but I can't seem to find an equivelant in C#.

What is the tersest way of accomplishing this in c#? I know I can set a boolean flag, and check it in the outer loop to break out of that one as well, but it just seems too verbose.

Thanks,

1

foreach(DataGridViewRow row in grid.Rows)
   foreach(DataGridView cell in row.Cells)
      if (cell.Value == somevalue) {
         // do stuff
         goto End;
      }
End:
   // more stuff

2

void Loop(grid) {
    foreach(row in grid.Rows)
       foreach(cell in row.Cells)
           if (something) {
               // do stuff   
               return;
           }
}

3

var cell = (from row in grid.Rows.OfType<DataGridViewRow>()
            from cell in row.Cells.OfType<DataGridViewCell>()
            where cell.Value == somevalue
            select cell
   ).FirstOrDefault();

if (cell != null) {
   // do stuff
}

Though many of the solutions above are correct and answer your question, I would take a step back and ask myself "is there another way to more clearly represent the semantics of the program?"

I would be inclined to write the code like this:

var query = from row in grid.Rows
            from cell in row.Cells
            where cell.Value == myValue
            select cell;
if (query.Any())
{
  // do something useful;
}

Why write any loops at all? You want to know if a particular collection has a particular member, so write a query that asks that question, and then examine the answer.

The most pleasant way is to break the second loop out into a function, like this:

public void DoubleLoop()
{
    for(int i = 0; i < width; i++)
    {
        for(int j = 0; j < height; j++)
        {
            if(whatever[i][j]) break; // let's make this a "double" break
        }
    }
}

goes to

public bool CheckWhatever(int whateverIndex)
{
    for(int j = 0; j < height; j++)
    {
        if(whatever[whateverIndex][j]) return false;
    }

    return true;
}

public void DoubleLoop()
{
    for(int i = 0; i < width; i++)
    {
        if(!CheckWhatever(i)) break;
    }
}

Of course, feel free to simplify this with LINQ or whatever (you could put CheckWhatever into the loop condition, too.) This is just a verbose demonstration of the principle.

I'd just wrap the loops into a function and have the function return as a way to exit the loops for my solution.

        foreach (DataGridViewRow row in grid.Rows)
        {
            foreach (DataGridViewCell cell in row.Cells)
            {
                if (cell.Value == myValue)
                {
                    goto EndOfLoop;
                    //Do Something useful
                    //break out of both foreach loops.
                }
            }
        
        }
        EndOfLoop: ;

that will work, but I would recommend using a boolean flag.

EDIT: Just to add a little more warning here; it is generally considered bad practice to use goto's as they quickly can lead to spaghetti code that is (nearly) impossible to maintain. That being said, it was included in the C# language, and is available for use, so clearly there are people who believe it has valid usages. Know that the feature exists and use with great caution.

For completeness, there's also the wrong way to do it:

try
{
    foreach(DataGridViewRow row in grid.Rows)
        foreach(DataGridViewCell cell in row.Cells)
            if(cell.Value == myValue)
               throw new FoundItemException(cell);
}
catch (FoundItemException ex)
{
    //Do Something useful with ex.item
}

C# does have a goto statement. In fact, the example on MSDN uses it to break out of a doubly-nested loop.

The best way is to not do this. Seriously; if you want to find the first occurrence of something in your nested loops, and then finish looking, then what you want to do is NOT to examine each element, which is explicitly just what the foreach construct does. I'd recommend using a regular for loop with a termination flag in the loop invariant.

You can write a class that implements IEnumerator<T> in the general case and then your enumeration code looks like this:

foreach (Foo foo in someClass.Items) {
    foreach (Bar bar in foo.Items) {
        foreach (Baz baz in bar.Items) {
            yield return baz;
        }
    }
}

// and later in client code

MyEnumerator e = new MyEnumerator(someClass);
foreach (Baz baz in e) {
    if (baz == myValue) {
        // do something useful
        break;
    }
 }

Here is an additional solution for the for-loop:

bool nextStep = true;
for (int x = 0; x < width && nextStep; x++) {
    for (int y = 0; y < height && nextStep; y++) {
        nextStep = IsBreakConditionFalse(x, y);
    }
}

1. Use go to as PeterAllenWebb as suggested.
2. Wrap the two for each loop into a function, and return when you want to break.

Did a bit google search, here is a similar question on MSDN forum.

  //describe how to find interesting cells
var query = from row in grid.Rows.OfType<DataGridViewRow>()
            from cell in row.Cells.OfType<DataGridViewCell>()
            where cell.Value == myValue
            select cell;
  //nab the first cell that matches, if any
DataGridViewCell theCell = query.FirstOrDefault();

  //see if we got one
if (theCell != null)
{
  //Do something with theCell
}

Put that into a function & use a return statement, when things are found.
At the end of it return a null value - indicating searched item not found.

You could modify your loop variable:

for (int i = 0; i < width; i++)
{
    for (int j = 0; j < height; j++)
    {
        if (NeedToBreak())
        {
            i = width;
            j = height; 
        }
    }

}

haven't tested yet... but something like this might work

            Action dostuff =  () =>
            {

            }
        foreach (DataGridViewRow row in grid.Rows)
            foreach (DataGridViewCell cell in row.Cells)
                if (cell.Value == myValue)
                    goto A:

        A: dostuff();

i think you can use custom exception for example:

private class CustomException : ScriptException
{
  public CustomException()
  {
  }
}

try
{
	foreach(DataGridViewRow row in grid.Rows)
	{
		foreach(DataGridViewCell cell in row.Cells)
		{
			if(cell.Value == myValue)
			    throw new CustomException();
		}
	}
}
catch(CustomException)
{ }

int i;
int j;
int flag = 0; // Flag used to break out of the nested loop.
char ballonColor;

if (b == NULL || b->board == NULL) { // Checks for a null board.
	flag = 0;
}
else {
	for (i = 0; i < b->rows && !flag; i++) { // Checks if the board is filled with air (no balloons).
		for (j = 0; j <= b->cols && !flag; j++) {
			if (b->board[i][j] != None) {
				flag = 1;
			}
		}
	}
}

if (flag == 0) {
	return 0;
}
else {
	for (i = 0; i < b->rows && !flag; i++) { //
		for (j = 0; j <= b->cols && !flag; j++) {
			if (b->board[i][j] != None) {
				ballonColor = b->board[i][j];
				if (i == 0) { // Top Row
					if (j == 0) {
						if (b->board[i + 1][j] == ballonColor || b->board[i][j + 1] == ballonColor) {
							return 1;
						}
					}
					else if (j == b->cols) {
						if (b->board[i + 1][j] == ballonColor || b->board[i][j - 1] == ballonColor) {
							return 1;
						}
					}
					else {
						if (b->board[i + 1][j] == ballonColor || b->board[i][j + 1] == ballonColor || b->board[i][j - 1] == ballonColor) {
							return 1;
						}
					}
				}
				else if (i == (b->rows - 1)) { // Bottom Row
					if (j == 0) {
						if (b->board[i - 1][j] == ballonColor || b->board[i][j + 1] == ballonColor) {
							return 1;
						}
					}
					else if (j == b->cols) {
						if (b->board[i - 1][j] == ballonColor || b->board[i][j - 1] == ballonColor) {
							return 1;
						}
					}
					else {
						if (b->board[i - 1][j] == ballonColor || b->board[i][j + 1] == ballonColor || b->board[i][j - 1] == ballonColor) {
							return 1;
						}
					}
				}
				else { // 
					if (j == 0) {
						if (b->board[i + 1][j] == ballonColor || b->board[i - 1][j] == ballonColor || b->board[i][j + 1] == ballonColor) {
							return 1;
						}
					}
					else if (j == b->cols) {
						if (b->board[i + 1][j] == ballonColor || b->board[i - 1][j] == ballonColor || b->board[i][j - 1] == ballonColor) {
							return 1;
						}
					}
					else {
						if (b->board[i + 1][j] == ballonColor || b->board[i - 1][j] == ballonColor || b->board[i][j + 1] == ballonColor || b->board[i][j - 1] == ballonColor) {
							return 1;
						}
					}
				}
			}
		}
	}
}

return 0;