面试回来，答题不会

Question

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                foo();
            }
            catch
            {
                Console.WriteLine("Exception Handler");
            }
        }
        static void foo()
        {
            using (TestClass tc = new TestClass())
            {
                throw null;
            }
        }
    }    class TestClass : IDisposable
    {
        ~TestClass() { Console.WriteLine("~TestClass"); }        public void Dispose() { Console.WriteLine("Dispose"); }
    }
}
输出什么为什么不是
Dispose
~TestClass
Exception Handler

Answer 1

你的Using模块运行到结束时，TestClass的Dispose()将会被执行;
接着 throw null;会被catch接住;程序退出是 析构函数执行,释放资源 

Answer 2

正确的顺序：
Dispose
Exception Handler
~TestClass
为什么~TestClass是在最后的？
 ~TestClass() { Console.WriteLine("~TestClass"); }
这个东西是方法还是其他东西？

Answer 3

Exception Handler
~TestClassfoo();   进入后  实例化TestClass tc = new TestClass()
抛出异常  输出Exception Handler
析构函数 最后输出~TestClass
感觉 呵呵

Answer 4

析构函数,无法调用,程序退出是,释放资源,此时执行经典的例子就是 class A
    {
        public A()
        {
            Console.WriteLine(" A被创建");
        }
        ~A()
        {
            Console.WriteLine(" A被释放");
        }
    }    class B : A
    {
        public B()
        {
            Console.WriteLine("B被创建");
        }
        ~B()
        {
            Console.WriteLine("B被释放");
        }    }
    class C : B
    {
        public C()
        {
            Console.WriteLine("c被创建");
        }        ~C()
        {
            Console.WriteLine("B被释放");
        }
    }  
    class Program
    {
        static void Main(string[] args)
        {
            C c = new C();
            Console.ReadLine();        }
    }分别按F5和ctrl+F5看看结果,你就明白了

Answer 5

LZ的题目我调试是Dispose
~TestClass

Answer 6

答案应该是：
Dispose
Exception Handler
~TestClassusing实质：
在程序编译阶段，编译器会自动将using语句生成为try-finally语句，并在finally块中调用对象的Dispose方法，来清理资源。
所以using (TestClass tc = new TestClass())等同于：
try{
   TestClass tc = new TestClass();
}catch(exception e){
}
finally{
   ((IDisposable)tc).Dispose();
}
所以，首先执行using (TestClass tc = new TestClass())这句
1. Using模块运行到结束时，TestClass的Dispose()将会被执行。
2. Exception被catch,所以执行Console.WriteLine("Exception Handler");
3. using{}后（tc对象只能在using{}内存活），对象tc需要被销毁，所以析构函数被调用。

Answer 7

1. Using()运行到结束时，TestClass的Dispose()将会被执行。
2. (throw null)Exception被catch,所以执行Console.WriteLine("Exception Handler");
3. using{}后（tc对象只能在using{}内存活），对象tc需要被销毁，所以析构函数被调用。

Answer 8

C#中析构函数，无法调用，由CLR决定何时调用。一般只需要实现IDispose来释放资源就好了，明白这个之后，这个题其实没什么意义

Answer 9

话虽然有理，但不适合这道题目，因为using(){}的存在，析构函数必然在最后被调用,因为该对象必须要被立刻销毁，而不是被动等待CLR来销毁。

Answer 10

http://www.cnblogs.com/paper/archive/2009/07/31/1535998.html  
此帖能加深理解

Answer 11

如果你要写析构函数，最好这样写：class Program
{
    static void Main(string[] args)
    {
        try
        {
            foo();
        }
        catch
        {
            Console.WriteLine("Exception Handler");
        }
    }
    static void foo()
    {
        using (TestClass tc = new TestClass())
        {
            throw null;
        }
    }
}class TestClass : IDisposable
{
    ~TestClass()
    {
        Console.WriteLine("~TestClass");
        this.Dispose();
    }    public void Dispose()
    {
        Console.WriteLine("Dispose");
        GC.SuppressFinalize(this);
    }
}

Answer 12

实际上，.net对象的析构函数并不一定执行。就好像这个对象（类），根本没有必要写析构函数，因为没有什么需要再次处理的，直接由GC释放了空间就行了。但是既然你一定要写析构函数，注意这不是c++而是.net，你的析构函数通常只是用来调用dispose的。

Answer 13

在c中一种概念是说析构函数用来释放空间，注意这个概念在.net中根本不成立。有些人把内存空间叫做“资源”这肯定就错了。释放空间是GC做的事情，你的析构函数根本不可能释放空间。你的析构函数也就是行使类似Dispose的功能而已。

Answer 14

使用using的前提是实现IDispose接口，而不是写析构，using完了调用的是IDispose的方法

Answer 15

Dispose
Exception Handler
，析构函数不执行

Answer 16

Dispose
Exception Handler
析构函数没执行

Answer 17

http://www.codeproject.com/KB/cs/tinguusingstatement.aspx

Answer 18

个人觉得不是using 结束调用Dispose(),而是using(TestClass tc = new TestClass())结束就调用Dispose()，而using(TestClass tc = new TestClass()){}结束后，{}这个是tc的存活范围，所以tc对象需要被销毁，所以此时系统会执行析构函数。
注意，我在vs2010下调试了，析构函数会被调用，如果有人说不会被调用，可能.net framework的版本不同吧

Answer 19

C#是不需要些析构函数，但是析构函数在c#依然存在，只是不能被程序员主动调用。这题不是考你using(){}Using()运行到结束时，TestClass的Dispose()将会被执行。而不是using(){}结束
using{}后（tc对象只能在using{}内存活），对象tc需要被销毁，所以系统会执行析构函数。我在vs2010下调是过了，析构函数会被最后执行的，如果有人析构函数没有执行，那可能是.net framework的版本问题

Answer 20

都没有说到点子上。因为throw会强制所有局部变量出栈，销毁，导致despose调用。自己搞清楚了。

Answer 21

tc是对象吧，存储在堆上，可不在stack里。唉，如果在using的语句段中，有继承了IDisposable
接口的实例对象的话，那dispose()是一定会被调用的，应该和throw没关系吧。求其它高人详解