C# Goto Statement – Understanding Goto in C# with Examples

Last updated on December 12th, 2023 at 04:58 am

The goto in C# is a jump statement that transfers the control to another part of the program.
In this article, we will learn in detail about the goto statement its advantages and disadvantages with code examples.

C# Goto Definition:

In C#, the goto statement is a jump statement used to transfer control to a labelled statement within the same method, switch statement, or loop.

However, the use of goto is generally discouraged in modern programming practices because it can make code harder to understand and maintain.

Here is a simple example of how goto can be used in C#:

using System;

class GotoExample
{
    static void Main()
    {
        int counter = 0;

        // The label where the program can jump to
        start:

        Console.WriteLine($"Counter: {counter}");

        counter++;

        // Check if counter is less than 5
        if (counter < 5)
        {
            // Jump to the 'start' label
            goto start;
        }

        Console.WriteLine("End of program");
    }
}

Output:

Counter: 0
Counter: 1
Counter: 2
Counter: 3
Counter: 4
End of program

Code Explanation:

In this example, the program uses a goto statement to jump back to the labelled statement “start” as long as the counter is less than 5. 

However, it’s important to note that in most cases, using structured control flow statements like for, while, and do-while is preferred over goto, as they lead to more readable and maintainable code.

We can use the goto statement in many different scenarios in C# programming such as:

• Breaking out of nested loops
• Jumping to error handling code
• Creating infinite loops
• Controlling the flow of complex logic

Example 1: Breaking out of nested loops using goto in C#:

In C#, We can use the goto statement to break out of nested loops. It can be especially useful when multiple nested loops are used, and the programmer wants to exit them simultaneously.

using System;
using System.IO;
namespace GotoExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // loop through values of i from 0 to 4
            for (int i = 0; i < 5; i++)
            {
                // nested loop through values of j from 0 to 4
                for (int j = 0; j < 5; j++)
                {
                    // output the values of i and j
                    Console.WriteLine("i: {0}, j: {1}", i, j);
                    // if j is equal to 2, jump to the label "end"
                    if (j == 2)
                    {
                        goto end;
                    }
                }
            }
            end:
            Console.WriteLine("Outside loops");
            Console.ReadLine();
        }
    }
}

Output:

i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
Outside loops

Example 2: Jumping to error handling code:

In C#, the goto statement can redirect the program flow to the error handling code in case an error occurs.

It could be helpful in scenarios where the error handling code is not located near the source of the error, and the programmer intends to make it easily accessible.

using System;
using System.IO;
namespace SystemIOExample
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int x = int.Parse("abc");
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e.Message);
                goto end;
            }
            end:
            Console.WriteLine("Outside try-catch block");
            Console.ReadLine();
        }
    }
}

Example 3: Creating infinite loops using goto in C#:

The goto in C# can be used to create infinite loops. It can be beneficial when the programmer wants to run a loop continuously until a specific condition is met.

 // Start label to repeat the process if the number entered is not greater than 10
            start:

            // Prompt user to enter a number greater than 10
            Console.WriteLine("Enter a number greater than 10:");

            // Read the user input and store it in the "number" variable
            int number = int.Parse(Console.ReadLine());

            // Check if the number entered is less than or equal to 10
            if (number <= 10)
            {
                // If the number is not greater than 10, go back to the start label
                goto start;
            }
            else
            {
                // If the number is greater than 10, print a message
                Console.WriteLine("Number is greater than 10");
            }
            Console.ReadLine();

Output:

Example 4: Using switch statement with goto in C#: 

We can also combine the goto statement with the switch statement in C#. This example demonstrates how we can implement a label within the switch statement to jump to a specific case.

Let’s take an example of a program that calculates the day of the week based on the number entered by the user.

using System;

namespace GotoExample4
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Enter a number between 1 to 7:");
            int day = Convert.ToInt32(Console.ReadLine());
            switch (day)
            {
                case 1:
                    Console.WriteLine("Monday");
                    break;
                case 2:
                    Console.WriteLine("Tuesday");
                    break;
                case 3:
                    Console.WriteLine("Wednesday");
                    break;
                case 4:
                    Console.WriteLine("Thursday");
                    break;
                case 5:
                    Console.WriteLine("Friday");
                    break;
                case 6:
                    Console.WriteLine("Saturday");
                    break;
                case 7:
                    Console.WriteLine("Sunday");
                    break;
                default:
                    Console.WriteLine("Invalid Input");
                    goto end;
            }
            Console.WriteLine("Thank you for using the program.");
            end:
            Console.WriteLine("Exiting the program.");
            Console.ReadLine();
        }
    }
}

Output:

Enter a number between 1 to 7:
5
Friday
Thank you for using the program.
Exiting the program.

Pros and Cons of the C# Goto Statement:

Certainly! While the goto statement in C# can be used in certain situations, it comes with both advantages and disadvantages. Here are the pros and cons of using the goto statement in C#:

Pros:

1. Simplifying Control Flow:
   • goto can be useful in certain scenarios where it simplifies control flow, especially when dealing with nested loops or complex switch statements.
2. Code Reusability:
   • In some cases, goto can be used to create reusable code blocks, as it allows you to jump to a specific labeled statement.
3. Legacy Code Compatibility:
   • When working with legacy code or maintaining code written by others, you may encounter the use of goto. Understanding its usage can be necessary for handling such scenarios.

Cons:

1. Readability and Maintainability:
   • The primary disadvantage of using goto is that it can make code less readable and harder to maintain. It disrupts the natural flow of code execution, making it difficult for developers to follow the logic.
2. Spaghetti Code:
   • Excessive use of goto can lead to “spaghetti code,” where the program’s structure becomes tangled and convoluted. This makes it challenging to understand, debug, and modify the code.
3. Error-Prone:
   • Misuse of goto can introduce subtle bugs and errors, especially when jumping across different parts of the code. It can lead to unexpected behavior and make it challenging to identify the source of issues.
4. Structured Alternatives:
   • Modern programming languages, including C#, provide structured control flow statements like if, for, while, and switch. These alternatives are generally preferred for their clarity and maintainability.
5. Not Recommended by Best Practices:
   • The use of goto is discouraged by coding standards and best practices in many programming communities. Most modern programming languages provide features that make structured control flow more expressive and readable.

FAQs

References: MSDN-Jump-Statements

Articles you might also like:

• C# Tutorial
• C# Programs asked in Interviews
• C# For Loop with examples
• C# While Loop with examples
• C# Do While Loop with examples
• if else vs switch condition
• Properties In C# with examples
• Local vs Global Variables
• C# stack vs heap
• IEnumerable Interface in C# with examples
• Constructors in C# with Examples
• C# Dictionary
• Is vs As operator in C#
• Abstract Factory Design Pattern in C#
• Singleton Design Pattern in C#
• Converting Celsius to Fahrenheit in C#

Please share this post and let us know what you think in the comments.

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• Difference Between Array And ArrayList In C#: Choosing the Right Collection - May 28, 2024
• C# Program to Capitalize the First Character of Each Word in a String - February 21, 2024
• C# Program to Find the Longest Word in a String - February 19, 2024