mcs/docs/ecma334/15.9.5.xml

   1 <?xml version="1.0"?>
   2 <clause number="15.9.5" title="The throw statement">
   3   <paragraph>The throw statement throws an exception. <grammar_production><name><non_terminal where="15.9.5">throw-statement</non_terminal></name> : <rhs><keyword>throw</keyword><non_terminal where="14.14">expression</non_terminal><opt/><terminal>;</terminal></rhs></grammar_production></paragraph>
   4   <paragraph>A throw statement with an expression throws the value produced by evaluating the expression. The expression must denote a value of the class type System.Exception or of a class type that derives from System.Exception. If evaluation of the expression produces null, a System.NullReferenceException is thrown instead. </paragraph>
   5   <paragraph>A throw statement with no expression can be used only in a catch block, in which case, that statement  re-throws the exception that is currently being handled by that catch block. </paragraph>
   6   <paragraph>Because a throw statement unconditionally transfers control elsewhere, the end point of a throw statement is never reachable. </paragraph>
   7   <paragraph>When an exception is thrown, control is transferred to the first catch clause in an enclosing try statement that can handle the exception. The process that takes place from the point of the exception being thrown to the point of transferring control to a suitable exception handler is known as exception propagation. Propagation of an exception consists of repeatedly evaluating the following steps until a catch clause that matches the exception is found. In this description, the throw point is initially the location at which the exception is thrown. <list><list_item> In the current function member, each try statement that encloses the throw point is examined. For each statement S, starting with the innermost try statement and ending with the outermost try statement, the following steps are evaluated: </list_item><list><list_item> If the try block of S encloses the throw point and if S has one or more catch clauses, the catch clauses are examined in order of appearance to locate a suitable handler for the exception. The first catch clause that specifies the exception type or a base type of the exception type is considered a match. A general catch (<hyperlink>15.10</hyperlink>) clause is considered a match for any exception type. If a matching catch clause is located, the exception propagation is completed by transferring control to the block of that catch clause. </list_item><list_item> Otherwise, if the try block or a catch block of S encloses the throw point and if S has a finally block, control is transferred to the finally block. If the finally block throws another exception, processing of the current exception is terminated. Otherwise, when control reaches the end point of the finally block, processing of the current exception is continued. </list_item></list><list_item> If an exception handler was not located in the current function member invocation, the function member invocation is terminated. The steps above are then repeated for the caller of the function member with a throw point corresponding to the statement from which the function member was invoked. </list_item><list_item> If the exception processing terminates all function member invocations in the current thread, indicating that the thread has no handler for the exception, then the thread is itself terminated. The impact of such termination is implementation-defined. </list_item></list></paragraph>
   8 </clause>