Try-with-resources in Kotlin

问题:

When I tried to write an equivalent of try-with-resources code in Kotlin it didn't work for me.

I tried different variations of the following:

try (writer = OutputStreamWriter(r.getOutputStream())) {
    // ...
}

But neither works.

Does anyone know what should be used instead? Apparently Kotlin grammar doesn't have definition for such a construct, but may be I'm missing something. It defines grammar for try block as follows:

try : "try" block catchBlock* finallyBlock?;

回答1:

There is use-function in kotlin stdlib (src).

How to use it:

OutputStreamWriter(r.getOutputStream()).use {
    // by `it` value you can get your OutputStreamWriter
    it.write('a')
}

回答2:

TL;DR

No special syntax, but use function

Kotlin, as opposed to Java, does not have a special syntax for this. Instead, try-with-resources, is offered as the standard library function use.

The use implementation

@InlineOnly
public inline fun <T : Closeable?, R> T.use(block: (T) -> R): R {
    var closed = false
    try {
        return block(this)
    } catch (e: Exception) {
        closed = true
        try {
            this?.close()
        } catch (closeException: Exception) {
        }
        throw e
    } finally {
        if (!closed) {
            this?.close()
        }
    }
}

This function is defined as a generic extension on all Closeable? types. Closeable is Java's interface that allows try-with-resources as of Java SE7.
The function takes a function literal block which gets executed in a try. Same as with try-with-resources in Java, the Closeable gets closed in a finally.

Also failures happening inside block lead to close executions, where possible exceptions are literally "suppressed" by just ignoring them. This is different from try-with-resources, because such exceptions can be requested in Java‘s solution.

How to use it

The use extension is available on any Closeable type, i.e. streams, readers and so on.

FileInputStream("filename").use {
   //use your stream by referring to `it` or explicitly give a name.
} 

The part in curly brackets is what becomes block in use (a lambda is passed as an argument here). After the block is done, you can be sure that FileInputStream has been closed.

回答3:

Edit: The following response is still valid for Kotlin 1.0.x. For Kotlin 1.1, there is support a standard library that targets java 8 to support closable resource pattern.

For other classes that do not support the "use" function, I have done the following homemade try-with-resources:

package info.macias.kotlin

inline fun <T:AutoCloseable,R> trywr(closeable: T, block: (T) -> R): R {
    try {
        return block(closeable);
    } finally {
        closeable.close()
    }
}

Then you can use it the following way:

fun countEvents(sc: EventSearchCriteria?): Long {
    return trywr(connection.prepareStatement("SELECT COUNT(*) FROM event")) {
        var rs = it.executeQuery()
        rs.next()
        rs.getLong(1)
    }
}