----------
20190708

What really happens in a 
try { return x; } finally { x = null; } 
statement?
https://stackoverflow.com/questions/421797/what-really-happens-in-a-try-return-x-finally-x-null-statement

I saw this tip in another question and was wondering if someone could explain to me how on earth this works? 
try { return x; } finally { x = null; }
I mean, does the finally clause really execute after the return statement? How thread-unsafe is this code? Can you think of any additional hackery that can be done w.r.t. this try-finally hack?

No - at the IL level you can't return from inside an exception-handled block. It essentially stores it in a variable and returns afterwards
i.e. similar to:

int tmp;
try {
  tmp = ...
} finally {
  ...
}
return tmp;

for example (using reflector):
static int Test() {
    try {
        return SomeNumber();
    } finally {
        Foo();
    }
}

compiles to:
.method private hidebysig static int32 Test() cil managed
{
    .maxstack 1
    .locals init (
        [0] int32 CS$1$0000)
    L_0000: call int32 Program::SomeNumber()
    L_0005: stloc.0 
    L_0006: leave.s L_000e
    L_0008: call void Program::Foo()
    L_000d: endfinally 
    L_000e: ldloc.0 
    L_000f: ret 
    .try L_0000 to L_0008 finally handler L_0008 to L_000e
}

This basically declares a local variable (CS$1$0000), places the value into the variable (inside the handled block), then after exiting the block loads the variable, then returns it. Reflector renders this as:
private static int Test()
{
    int CS$1$0000;
    try
    {
        CS$1$0000 = SomeNumber();
    }
    finally
    {
        Foo();
    }
    return CS$1$0000;
}
編譯成 IL 碼如上: 在整個 try 區塊中, 並不會直接 return 結束, 必須執行到 finally 才能結束. 即使有回傳值, 也會以區塊內的暫存變數先存放後, 直到執行完 finally 後才回傳.


The finally statement is executed, but the return value isn't affected. The execution order is:
Code before return statement is executed
Expression in return statement is evaluated
finally block is executed
Result evaluated in step 2 is returned
Here's a short program to demonstrate:
using System;

class Test
{
    static string x;

    static void Main()
    {
        Console.WriteLine(Method());  // return "try"
        Console.WriteLine(x);         // return "finally"
    }

    static string Method()
    {
        try
        {
            x = "try";
            return x;
        }
        finally
        {
            x = "finally";
        }
    }
}
如果 try 區塊中回傳的變數改為 static 方式存放時, 這是最容易混淆的狀況, 應盡量避免這樣寫程式. 如上例.
則 (函數回傳值)為(暫存的結果)
且 (static變數結果) 為 (finally的結果)
結論就是: 最後一定會執行(finally區塊)!
This prints "try" (because that's what's returned) and then "finally" because that's the new value of x.
Of course, if we're returning a reference to a mutable object (e.g. a StringBuilder) then any changes made to the object in the finally block will be visible on return - this hasn't affected the return value itself (which is just a reference).





----------
20190628

try…catch只有在發生Exception時才會影響效能, 測試約需多耗費一倍以上的執行時間.

// try_catch_finally.cs
using System;
public class EHClass
{
    static void Main()
    {
        try
        {
            Console.WriteLine("Executing the try statement.");
            throw new NullReferenceException();
        }
        catch (NullReferenceException e)
        {
            Console.WriteLine("{0} Caught exception #1.", e);
        }
        catch
        {
            Console.WriteLine("Caught exception #2.");
        }
        finally
        {
            Console.WriteLine("Executing finally block.");
        }
    }
}
----------
// try_catch_example.cs
using System;
class MainClass
{
    static void ProcessString(string s)
    {
        if (s == null)
        {
            throw new ArgumentNullException();
        }
    }
    
    static void Main()
    {
        try
        {
            string s = null;
            ProcessString(s);
        }
        catch (Exception e)
        {
            Console.WriteLine("{0} Exception caught.", e);
        }
    }
}

----------

two catch statements

// try_catch_ordering_catch_clauses.cs
using System;
class MainClass
{
    static void ProcessString(string s)
    {
        if (s == null)
        {
            throw new ArgumentNullException();
        }
    }

    static void Main()
    {
        try
        {
            string s = null;
            ProcessString(s);
        }
        // Most specific:
        catch (ArgumentNullException e)
        {
            Console.WriteLine("{0} First exception caught.", e);
        }
        // Least specific:
        catch (Exception e)
        {
            Console.WriteLine("{0} Second exception caught.", e);
        }
    }
}

----------
using System;
using System.IO;
public class ProcessFile
{
   public static void Main()
      {
      FileStream fs = null;
         try
            //Opens a text tile.
            {
            fs = new FileStream("data.txt", FileMode.Open);
            StreamReader sr = new StreamReader(fs);
            string line;
            //A value is read from the file and output to the console.
            line = sr.ReadLine();
            Console.WriteLine(line);
            }
         catch(FileNotFoundException e)
            {
            Console.WriteLine("[Data File Missing] {0}", e);
            throw new FileNotFoundException("[data.txt not in c:\\dev directory]",e);
            }
         finally
            {
            fs.Close();
            }
      }
}