logoalt Hacker News

brewmarche • yesterday at 1:14 PM • 2 replies • view on HN

In C# the closest analogue to a C++ destructor would probably be a `using` block. You’d have to remember to write `using` in front of it, but there are static analysers for this. It gets translated to a `try`–`finally` block under the hood, which calls `Dispose` in `finally`.

    using (var foo = new Foo())
    {
    }
    // foo.Dispose() gets called here, even if there is an exception
Or, to avoid nesting:

    using var foo = new Foo(); // same but scoped to closest current scope
These also is `await using` in case the cleanup is async (`await foo.DisposeAsync()`)

I think Java has something similar called try with resources.

Replies

cogman10 • yesterday at 3:13 PM

Java's is

    try (var foo = new Foo()) {
    }
    // foo.close() is called here.
I like the Java method for things like files because if the there's an exception during the close of a file, the regular `IOException` block handles that error the same as it handles a read or write error.
➕ show 1 reply
mort96 • yesterday at 3:32 PM

That approach doesn't allow you to move the file into some long lived object or return it in the happy path though, does it?

➕ show 2 replies