c#   programming practices   goto


Why is this even a debate?

First of all, strongly held beliefs are rarely a good thing, if ever. So it’s not a bad idea to see why goto, despite being frowned upon so hard that your brows merge into one, still exists in C#. Granted, it’s ugly and messy, and a maintenance nightmare, but turns out it can still be useful in a handful of cases.

Original Article

This article Why goto Still Exists in C# by Steve Wellens is an excellent write-up. There’s not much I can add to it and I pretty much agree with everhthing there. Well everything except that people who use tabs kick puppies. It’s the space indenters that kick puppies, you monsters.

I’m simply reproducing the article below just in case the link goes dead. All credit attributed to Steve.


Why goto Still Exists in C# Language

Developers, Software Engineers, and Programmers are logical, rational, reasonable people right? Sure they are…until you disagree with something they believe in. Then they can become the most enflamed, outraged, foaming-at-the-mouth, intolerant, lunatics you’ve ever had the pleasure of meeting.

Take for instance the goto command. It can create emotions as intense as those raised during the ancient ‘tabs versus spaces’ debates or whether or not curly braces should be aligned in columns. (For the record, developers who use tabs and don’t line up curly braces also kick puppies and do not practice good hygiene).

You can program for years and never use a goto. However, there are times when a goto can make the code simpler and that…is a very good thing.

Here’s a scenario: You are working on a multi-threaded real-time program. You can’t use the debugger because stepping through the code would mess up the timings and interactions between the threads. You also need something to help diagnose problems in the field. A runtime log that can be turned on and off is used. The requirement is that every function will log its entry and exit point. That way if something goes wrong, the log will show what function failed and where it failed.

In one area of the program, you need to perform several steps in sequence. If any step fails, the remaining steps must not execute.

Here’s the first attempt:

// Do Process using nested if statements

void DoProcess1()
{
    LOG("DoProcess Started...");
 
    if (Step1() == true)
        if (Step2() == true)
            if (Step3() == true)
                if (Step4() == true)
                    if (Step5() == true)
                        if (Step6() == true)
                            Step7();
 
    LOG("DoProcess Finished");
}

Sure it works but getting code to work is only the first step. Creating clear, maintainable code is the goal. If the code can be simplified, you are not done.

Second attempt, use a flag variable:

// Do Process using a success flag

void DoProcess2()
{
    LOG("DoProcess Started...");
 
    bool Success;
 
    Success = Step1();
    if (Success == true)
        Success = Step2();
    if (Success == true)
        Success = Step3();
    if (Success == true)
        Success = Step4();
    if (Success == true)
        Success = Step5();
    if (Success == true)
        Success = Step6();
    if (Success == true)
        Success = Step7();
 
    LOG("DoProcess Finished");
}

That’s better but it can be simplified further:

Third attempt with goto:

// DoProcess using goto

void DoProcess3()
{
    LOG("DoProcess Started...");
 
    if (Step1() == false)
        goto EXIT;
    if (Step2() == false)
        goto EXIT;
    if (Step3() == false)
        goto EXIT;
    if (Step4() == false)
        goto EXIT;
    if (Step5() == false)
        goto EXIT;
    if (Step6() == false)
        goto EXIT;
    if (Step7() == false)
        goto EXIT;
 
EXIT:
    LOG("DoProcess Finished");
}

The creation, assigning and checking of a variable has been eliminated. It also runs faster but the speed improvement is insignificant and not a reason for using a goto.

The example is trivial, however in real life, being able to jump to the end of complicated functions can dramatically reduce the complexity of code.

Before you disagree with the inclusion of the goto in the C# language, remember you are disagreeing with the people who created the language. You are also disagreeing with Steve McConnel the author of Code Complete.

In my career, I’ve only used a goto once and I had to present the code to a code-review group of four developers. When I showed the code with and without the goto, they unanimously agreed without any discussion that goto was… the way to go. Pun intended.

I hope someone finds this helpful.

[Update: July 3, 2009]

Here are two more examples of when a goto is helpful. The first is from Charles Petzold’s book .Net Book Zero a free pdf book available here .

A switch fall through is illegal in C# (this causes a compiler error):

switch (a) 
{ 
    case 3: 
        b = 7; 
    case 4: 
        c = 3; 
        break; 
    default: 
        b = 2; 
        c = 4; 
        break; 
}

To get it to work you can use a goto:

switch (a) 
{ 
    case 3: 
        b = 7;
        goto case 4;
    case 4: 
        c = 3; 
        break; 
    default: 
        b = 2; 
        c = 4; 
        break; 
}

This example shows better how to cleanly get out of nested loops/code. The task is to search a three dimensional array and check for a null value:

bool GetData()
{
    String[,,] Data = new String[5, 5, 5];
 
    // ....code to fill in array here

 
    for (int x = 0; x < 5; x++)
    {
        for (int y = 0; y < 5; y++)
        {
            for (int z = 0; z < 5; z++)
            {
                if (Data[x, y, z] == null)
                    goto NULL_FOUND;
            }
        }
    }
 
    return true;
 
NULL_FOUND:
    Response.Write("Invalid Data");
    return false;
}