resource-management

I'm a C++ amateur. I'm writing some Win32 API code and there are handles and weirdly compositely allocated objects aplenty. So I was wondering - is there some wrapper class that would make resource management easier? For example, when I want to load some data I open a file with CreateFile() and get a HANDLE . When I'm done with it, I should call CloseHandle() on it. But for any reasonably complex loading function there will be dozens of possible exit points, not to mention exceptions. So it would be great if I could wrap the handle in some kind of wrapper class which would automatically call

Are Locks AutoCloseable? That is, instead of: Lock someLock = new ReentrantLock(); someLock.lock(); try { // ... } finally { someLock.unlock(); } can I say: try (Lock someLock = new ReentrantLock()) { someLock.lock(); // ... } in Java 7? dlev No, neither the Lock interface (nor the ReentrantLock class) implement the AutoCloseable interface, which is required for use with the new try-with-resource syntax. If you wanted to get this to work, you could write a simple wrapper: public class LockWrapper implements AutoCloseable { private final Lock _lock; public LockWrapper(Lock l) { this._lock = l;

C# has using with the IDisposable interface. Java 7+ has identical functionality with try and the AutoCloseable interface. Scala lets you choose your own implementation to this issue. scala-arm seems to be the popular choice, and is maintained by one of the Typesafe employees. However, it seems very complicated for such a simple behavior. To clarify, the usage instructions are simple, but understanding how all that code is working internally is rather complex. I just wrote the following super simple ARM solution: object SimpleARM { def apply[T, Q](c: T {def close(): Unit})(f: (T) => Q): Q = {

I just played with Java file system API, and came down with the following function, used to copy binary files. The original source came from the Web, but I added try/catch/finally clauses to be sure that, should something wrong happen, the Buffer Streams would be closed (and thus, my OS ressources freed) before quiting the function. I trimmed down the function to show the pattern: public static void copyFile(FileOutputStream oDStream, FileInputStream oSStream) throw etc... { BufferedInputStream oSBuffer = new BufferedInputStream(oSStream, 4096); BufferedOutputStream oDBuffer = new

I was trying to explain to someone why database connections implement IDisposable, when I realized I don't really know what "opening a connection" actually mean. So my question is - What does c# practically do when it opens a connection? Thank you. There are actually two classes involved in implementing a connection (actually more, but I'm simplifying). One of these is the IDbConnection implementation ( SQLConnection , NpgsqlConnection , OracleConnection , etc.) that you use in your code. The other is a "real" connection object that is internal to the assembly, and not visible to your code. We

I have seen many examples of ARM (automatic resource management) on the web for Scala. It seems to be a rite-of-passage to write one, though most look pretty much like one another. I did see a pretty cool example using continuations, though. At any rate, a lot of that code has flaws of one type or another, so I figured it would be a good idea to have a reference here on Stack Overflow, where we can vote up the most correct and appropriate versions. chengpohi For now Scala 2.13 has finally supported: try with resources by using Using :), Example: val lines: Try[Seq[String]] = Using(new