115.10 The try statement

Chapter 15 Statements

1Within a catch block, a throw statement (§15.9.5) with no expression can be used to re-throw the

2exception that was caught by the catch block. Assignments to an exception variable do not alter the

3exception that is re-thrown.

4[Example: In the following code

5using System;

6class Test

7{

28}

29}

30the method F catches an exception, writes some diagnostic information to the console, alters the exception

31variable, and re-throws the exception. The exception that is re-thrown is the original exception, so the output

32produced is:

33Exception in F: G

34Exception in Main: G

35If the first catch block had thrown e instead of rethrowing the current exception, the output produced would

36be as follows:

37Exception in F: G

38Exception in Main: F

39end example]

40It is a compile-time error for a break, continue, or goto statement to transfer control out of a finally

41block. When a break, continue, or goto statement occurs in a finally block, the target of the statement

42shall be within the same finally block, or otherwise a compile-time error occurs.

43It is a compile-time error for a return statement to occur in a finally block.

44A try statement is executed as follows:

45• Control is transferred to the try block.

46• When and if control reaches the end point of the try block:

47o If the try statement has a finally block, the finally block is executed.

48o Control is transferred to the end point of the try statement.

49• If an exception is propagated to the try statement during execution of the try block:

50o The catch clauses, if any, are examined in order of appearance to locate a suitable handler for the

51exception. The first catch clause that specifies the exception type or a base type of the exception

235

Chapter 15 Statements

115.12 The lock statement

2The lock statement obtains the mutual-exclusion lock for a given object, executes a statement, and then

3releases the lock.

4lock-statement:

6The compile time type of the expression of a lock statement shall be a reference-type or a type parameter

7(§26.1.1). It is a compile-time error for the compile time type of the expression to denote a value-type. When

8the compile time type of expression is a type parameter (§26.1.1) and the run-time type of the expression is a

9value type, the value of the expression is boxed and the mutual exclusion lock is obtained on the boxed

10value. In this case the locking will have no effect since the boxed value could not have any other references

11to it.

12A lock statement of the form

13lock (x) …

14is precisely equivalent to:

15object obj = x;

16System.Threading.Monitor.Enter(obj);

17try {

18…

19}

20finally {

21System.Threading.Monitor.Exit(obj);

22}

23[Example:

24class Cache

25{

36private readonly object key = new object();

37}

38end example]

3915.13 The using statement

40The using statement obtains one or more resources, executes a statement, and then disposes of the resource.

41using-statement:

46A resource is a class or struct that either has a suitable Dispose method or implements the

47System.IDisposable interface. The System.IDisposable interface includes a single parameterless

48method named Dispose. Code that is using a resource can call Dispose to indicate that the resource is no

49longer needed. If Dispose is not called, then automatic disposal eventually occurs as a consequence of

50garbage collection (assuming the destructor of the resource type calls Dispose or otherwise performs the

51equivalent actions).

237

C# LANGUAGE SPECIFICATION

1Local variables declared in a resource-acquisition are read-only, and shall include an initializer. A compile-

2time error occurs if the embedded statement attempts to modify these local variables (via assignment or the

3++ and -- operators) or pass them as ref or out parameters.

4A using statement is translated into three parts: acquisition, usage, and disposal. Usage of the resource is

5implicitly enclosed in a try statement that includes a finally clause. This finally clause disposes of the

6resource. If a null resource is acquired, then no call to Dispose is made, and no exception is thrown.

7A using statement of the form

8using (expression) embedded-statement

9is equivalent to a using statement of the form:

10using (ResourceType resource = expression) embedded-statement

11where ResourceType is the type of the expression and the resource variable is not visible to or

12accessible from any source code of the program.

13A using statement of the form

14using (ResourceType resource = expression) embedded-statement

15corresponds to the expansion:

16{

23}

24}

25The resource variable is read-only in the embedded statement.

26The precise form of the finally block is determined as follows:

27• First determine whether the resource type R has an appropriate Dispose method:

28o Perform member lookup on the type R with identifier Dispose and no type arguments. If the

29member lookup does not produce a match or produces an ambiguity or produces a match that is not

30a method group, check for the System.IDisposable interface as described below. It is

31recommended that a warning be issued if member lookup produces anything except a method group

32or no match.

33o Perform overload resolution using the resulting method group and an empty argument list. If

34overload resolution results in no applicable methods or results in an ambiguity or results in a single

35best method but that method is either static or not public or has a return type other than void, check

36for the System.IDisposable interface as described below. It is recommended that a warning be

37issued if overload resolution produces anything except an unambiguous public instance method with

38void return type or no applicable methods.

39o If ResourceType is a value type or a type parameter with the value type constraint (§26.7), the

40finally clause is expanded to:

41finally {

42resource.Dispose();

43}

44o Otherwise, the finally clause is expanded to:

45finally {

46if (resource != null) resource.Dispose();

47}

48• Otherwise, check for the System.IDisposable interface:

238