The switch statement in C# differs from Java in three ways:

The example below demonstrates these differences:

public void MyMethod(string color) {

    switch (color.ToLower()) {    // Note – using a string

        case "orange":
        case "red":
            SomeMethod();
            goto default;    // Note – jump to default clause

        case "aqua":
        case "blue":
            SomeOtherMethod();
            break;

        case "green":
            SomeThirdMethod();
            goto case "red";    // Note – jump to "red" clause

        default:
            SomeDefaultMethod();
            break;
    }
}

The C# foreach statement iterates through the elements of a collection. For the purpose of the foreach statement, a collection is

The syntax of a foreach statement is

foreach (type identifier in collection) statement

The type and identifier declare a read-only local iteration variable that’s available within the scope of the statement.

The following example of the foreach statement iterates through the contents of a string array and prints out each element:

string[] days = new string[] {"Monday", "Tuesday", "Wednesday"};
foreach (string myString in days) {
    System.Console.WriteLine(myString);
}

The return statement has the same function and syntax in both C# and Java.

See the section Exceptions and Exception Handling in Chapter 6 for details of the throw statement.

C# supports both the break and continue statements but does not support the use of label identifiers as targets of these statements.

The C# goto statement allows an unconditional jump to a labeled statement. The goto might cause execution to jump either forward or backward in the code, but the goto statement must be within the scope of the target labeled statement. Because Java doesn’t currently implement the goto keyword, the nearest equivalent of the C# goto statement in Java is targeted break or continue statements, although these do not provide the same levels of flexibility. Note the following:

See Chapter 6 in Chapter 6 for details of the try statement.

The C# keyword lock is nearly equivalent to the Java keyword synchronized. The principle difference is that the lock keyword cannot be used as a modifier to synchronize access to an entire method. It’s applicable only to statement blocks, as in the following example:

public void SampleMethod() {
    lock(SomeObject) {
        // statements needing synchronized access
    }
    return;
}

Arithmetic overflow occurs when the result of an integer type mathematical operation or conversion is greater or smaller than can be represented by the defined data type. For example, in Java and C#, a short can contain integer values between -32,768 and 32,767. The following code demonstrates arithmetic overflow in Java:

short x = 32767;
x++;
System.out.println(x);

The output from the above code will be -32768.

Java handles integral arithmetic overflow by truncating the high-order bits, resulting in the cyclical effect just demonstrated. In C#, the checked and unchecked keywords allow control of the compile-time and run-time handling of integral arithmetic overflow.

Technically, the checked and unchecked keywords are operators as well as statements. The checked and unchecked keywords use the same syntax. An example of a checked expression and statement is included in the following code fragment:

// A checked expression
int b = checked (x * 5);

// A checked statement block
checked {
    int p = x++;
    int q = x * 5;
    int r = p * q;
}

A compiler error is reported if the value of the checked expression can be resolved at compile time and overflow occurs. If the value of the checked expression cannot be determined until run time, overflow causes a System.OverflowException to be thrown. The use of the unchecked keyword forces truncation, causing any errors or exceptions to be suppressed and resulting in the same cyclic behavior seen with Java.

If neither checked nor unchecked is specified in the code, the following defaults are used:

The default compile-time overflow checking can be modified by using the /checked compiler flag. See Chapter 3 for details of compiler flags.

The using keyword represents both a statement and a directive. The using directive is for importing namespaces into an application. See the Namespaces section earlier in this chapter for details. The using statement is a mechanism for efficiently acquiring, using, and disposing of a class or struct that implements the System.IDisposable interface. For example, if MyClass and MyStruct are types that implement IDisposable, the syntax of the using command is as follows:

using (MyClass x = new MyClass(), MyStruct y = new MyStruct()) {
    // do something with x and y
    x.someMethod();
    y.someOtherMethod();
} // x and y are automatically disposed of

The objects specified in the using statement are available within the scope of the statement block. At the end of the statement block, the Dispose method of the IDisposable interface is automatically called on each object. The using statement automatically wraps the necessary try...catch...finally structure around the statement block. This ensures that the objects are disposed of irrespective of whether an exception causes the program to leave the statement block or the statement exits normally.

For information on the fixed statement, see the Unsafe Code section in Chapter 6.