与 C++ 析构函数相比，C# 析构函数和 GC 并不能真正解决问题

Question

编辑：这个问题旨在比较 C# 和 C++ 实现。讨论时无需戏剧化。无论如何，我个人更喜欢用 C# 开发。

假设我有以下课程：

class Foo {
            FileStream f;
            public Foo() {
                f = File.Open("somefile.txt", FileMode.Open);
            }
            ~Foo() {
                f.Close();
            }
        }

然后我在 Main 中调用以下内容：

static void Main(){
    doSomething();
    // this one creates an exception, file in use
    doSomething();
}
static void doSomething(){
    Foo f = new Foo();
}

在 C++ 中，这段代码可以正常工作：

    class Foo {
public:
    std::ofstream ofs;
    Foo() { ofs = ofstream("somefile.txt"); }
    ~Foo() { ofs.close(); }
};

void doSomething() {
    Foo f();
}

int main() {
    doSomething();
    doSomething();
    return 0;
}

当第一个doSomething() 超出范围时，第一个对象调用其析构函数并关闭文件。

在 C# 中，这总是会抛出一个异常，说明该文件正在被另一个进程使用。显然没有调用析构函数。

参考 MSDN 关于析构函数的页面here，它会使阅读它的人感到困惑，并让他们认为这实际上是一个析构函数。虽然它实际上是 GC 决定调用它时由 GC 调用的终结器，但我无法控制。

是的，我可以实现IDisposeable，但我不希望每个使用我的库的程序员都记得调用Dispose()，否则他会遇到未处理的异常。

我可以在两个doSomething() 方法之间调用GC.Collect() 并且不会抛出异常。再一次，这将类似于Dispose()，图书馆的用户必须记住它。没有提到来自 MS 的无数警告告诉人们请不要使用GC.Collect() ！

所以我的问题是，如果 MS 想要像 C++ 那样拥有析构函数，他们是否只需要在每次方法超出范围时调用垃圾收集器？还是对他们来说会更复杂？这样的设计会有什么样的复杂性？

另外，如果很简单，他们为什么不做呢？

此外，有没有办法强制 C# 中的析构函数在超出范围时被调用？

编辑：

我正在查看 C++/CLI 实现，有趣的是，关键字 gcnew 恰好允许我希望 C# 发生的事情。所以答案就在那个实现中。在他们的文档中，当托管对象超出范围时，将调用 GC 并调用托管对象的析构函数。这并不强制用户手动Dispose 对象。

这回答了一个问题，即当对象超出范围时，MS 使 GC 以类似方式工作有多“难”。它只是自动调用GC.Collect()，这会强制 GC 调用析构函数，类似于 C++ 中发生的情况。

Answer 1

正如您所推测的，C# 没有确定性析构函数，将其与 C++ 进行比较总是“苹果对橘子”。此外，在 C# 类上实现析构函数将导致该类实例的 GC 清理更加不确定，因为 GC 会将任何具有析构函数的实例放入列表中，稍后由单独的线程处理。

如果您想要确定性地处理实例，请实现IDisposable 接口/模式。这就是它的用途。

Answer 2

这不是 C# 问题。您的班级应该正确处理打开和关闭。

public static class Foo
{
    public static void DoSomething()
    {
        string someText = "someText";
        using (StreamWriter writer = new StreamWriter("myfile.txt"))
        {
            writer.Write(someText);
            writer.Close();
            writer.Dispose();
        }
    }
}