The diff between throw and throw e

　　Today, in the interview,this question be asked, but I cant't  answer because I am cpluspluser before, I turn to learn C# not long.

　　So, what the different between throw and throw e? I found a amasing answer here when I  search some information with google.

　　I run the program in vs2008, the code is :　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DiffBetweenThrowAndThrowE
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                ThrowException1(); // line 14
            }
            catch (Exception x)
            {
                Console.WriteLine("Exception 1:");
                Console.WriteLine(x.StackTrace);
            }

            try
            {
                ThrowException2(); // line 24
            }
            catch (Exception x)
            {
                Console.WriteLine("Exception 2:");
                Console.WriteLine(x.StackTrace);
            }
        }

        private static void ThrowException1()
        {
            try
            {
                DivByZero(); // line 37
            }
            catch
            {
                throw; // line 41
            }
        }

        private static void ThrowException2()
        {
            try
            {
                DivByZero(); // line 49
            }
            catch (Exception ex)
            {
                throw ex; // line 53
            }
        }

        private static void DivByZero()
        {
            int x = 0;
            int y = 1 / x; // line 60
        }
    }
}

　　The resualt of the program is:

What's the same:

1. Both throw an exception.
2. Both have the same debuggability problems associated with catch / rethrow.
3. They can be called in the same way.  I used code like:

   catch (Exception e)
   {            
       if (...) 
           throw;
       else
           throw e;
   
   

   as an academic way to demonstrate that they must have some similar properties. Never actually write code like that!

4. They can both be used in a naked catch block, although as difference #1 below mentions, 'throw e'; can't be used to rethrow the current exception.　　

catch
{
        thrownew MyWrapperException();
}

What's different:

1. 'throw;' can only be used in the lexical scope of a catch block since it must gaurantee having a current exception. 'throw e' can be used anywhere.
2. 'throw e' lets you provide a new exception object, such as a wrapper around the original exception.
3. Only 'throw' can be used to rethrow the current exception within a naked catch block
4. They both rethrow the current exception object, but “throw e;” resets parameters on it like the Exception.StackWalk property.
5. They generate different IL opcodes. C#'s 'throw;' compiles to the 'rethrow' IL opcode, which doesn't take any parameters on the IL stack. 'throw e;' compiles to the 'throw' IL opcode, which takes 1 IL stack parameter: the exception to throw.

中文意思：

　　1.throw： CLR会保留原始的异常栈信息。这样方便调试很容易找到出错的行号

　　2. throw e: CLR也会保留异常信息，但会修改异常堆栈信息，所以StackTrace异常的行不是try里的实现出错行，而是throw e 的出错行，这样对于调试为说，有点误导作用，但你可以在throw e的时候将异常的原因写明白一抛出，比如：

try {
   ...
} catch (IOException e) {
   ...
   throw new ApplicationException("Some informative error message", e);
}

这也是它的优点所在