Kotlin try catch with resources

Try-with-resources in Kotlin

Kotlin is very efficient in managing the memory. Unlike Java, developers in Kotlin need not have to manage the memory explicitly. We do have different kinds of memory management techniques and Try-with-resource is one of them. In Kotlin, we have a function called ‘use‘ which takes the burden of managing the resources automatically. This is a part of std library function provided by Kotlin.

As per Kotlin documentation, use() is defined as a generic extension on all closeable types. The implementation looks like this −

public inline fun T.use(block: (T) -> R): R <>

• In the above function, the definition block is the function that processes the closeable resource.
• fun is the function call which returns the result of the block function.

Example: use() Implementation

In this example, we will see how to use the use() function in order to implement try-with-resources. We will use the use() method on bufferedReader() to read the content of «myFile.txt«.

import java.io.File fun main(args: Array) < val readMyFile = File("myFile.txt") readMyFile .bufferedReader().use< println(it.readText()) >>

Output

Once the above piece of code is executed, it should read all the content of the file provided inside the file object. If you run it in Kotlin playground (https://play.kotlinlang.org/), it will throw a security exception, as you don’t have permission to read from the playground server.

Exception in thread "main" java.io.FileNotFoundException: myFile.txt (No such file or directory) at java.io.FileInputStream.open0(Native Method) at java.io.FileInputStream.open(FileInputStream.java:195) at java.io.FileInputStream.(FileInputStream.java:138) at MainKt.main(main.kt:4)

Источник

Try-with-resources in Kotlin

Apparently Kotlin grammar doesn’t include such a construct, but maybe I’m missing something. Question: When I tried to write an equivalent of a Java -with-resources statement in Kotlin, it didn’t work for me.

Try-with-resources in Kotlin

When I tried to write an equivalent of a Java try -with-resources statement 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 include such a construct, but maybe I’m missing something. It defines the grammar for a try block as follows:

try : "try" block catchBlock* finallyBlock?; 

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

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

TL;DR: No special syntax, just a 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 .

FileInputStream("filename").use < fis ->//or implicit `it` //use stream here > 

The use implementations

@InlineOnly public inline fun 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.

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 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) >> 

Since this StackOverflow post is near the top of the current search results for «kotlin closeable example,» and yet none of the other answers (nor the official docs) clearly explain how to extend Closeable (a.k.a. java.io.Closeable ), I thought I’d add an example of how to make your own class that extends Closeable . It goes like this:

import java.io.Closeable class MyServer : Closeable < override fun close() < println("hello world") >> 

See this example in the Kotlin Playground here.

How to Use try – catch as an Expression in Kotlin?

The try statement consists of a try-block, which contains one or more statements. < >must always be used, even for single statements. A catch-block, a finally-block, or both must be present. This gives us three forms for the try statement:

A catch-block contains statements that specify what to do if an exception is thrown in the try-block. If any statement within the try-block (or in a function called from within the try-block) throws an exception, control is immediately shifted to the catch-block. If no exception is thrown in the try-block, the catch-block is skipped. You can nest one or more try statements. If an inner try statement does not have a catch-block, the enclosing try statement’s catch block is used instead. The finally-block will always execute after the try-block and catch-block(s) have finished executing. It always executes, regardless of whether an exception was thrown or caught.

try – catch as an expression

Exceptions in Kotlin are both similar and different compared to those in Java. In Kotlin, throwable is the superclass of all the exceptions, and every exception has a stack trace, message, and an optional cause. The structure of try-catch is also similar to that used in Java. In Kotlin, here’s how a try-catch statement looks:

Источник

Kotlin try-with-resources

The following article provides an outline for Kotlin try-with-resources. Kotlin try with resources is used to manage the memory in kotlin, kotlin is managing the memory in very efficient way. As per java developers in kotlin we have no need to manage the memory explicitly. In kotlin, we are using try with resources technique for managing the memory. In kotlin language we have function as use which was taking the burden for managing resources automatically.

The kotlin try with resources is the part of the function of the standard library which was provided by kotlin. As per the documentation of kotlin the use function is defined as an extension of generic on all the types which was closable. In a use function, the block of definition is a function that processes the closeable resources. Basically in kotlin try with resources is a try statement which was used to declare one or more resources. A resource is nothing but an object which was closed once in our program is done by using it. For example, socket connection resource.

Web development, programming languages, Software testing & others

Key Takeaways

• Try with resource statement in kotlin will allow us to provide a set of resources that was automatically closed after our code complete its execution.
• We have no need to close files manually. We are using use function in kotlin instead of this function which was used in java.

Why Use Kotlin try-with-resources?

The try with resource statement will ensure that each resource will close at the end of executing the statement. Suppose we are not closing the resources, it will constitute a leak of resource, and our program is also exhausting the resource which was available for it. We are passing an object as a resource, which was implementing the auto closeable object, which includes the object which was implemented by using an object as closeable. By using kotlin try with resource we have no need to add the extra finally block just passing the closing statement for the resources.

At the time of coming exception block, there is a difference between the block of try, catch, and finally and the block of try with resource. Suppose exception is thrown from both try and finally block, then the exception which was thrown from try with the resource is the suppressed exception.

Below example shows why we are using try with resources as follows:

import java.io.File fun main (args: Array) < val trywith = File ("kotlin.txt") trywith.bufferedReader ().use < println (it.readText()) >>

In the above example, we are using the main function, in the main function we are defining the array string also we are using bufferedReader and use a function with the variable of trywith.

Kotlin try-with-resources Management

We can define the three different phases at the time of working with kotlin try with resources. Below example shows kotlin try with resource management as follows:

import java.io.File fun main(args: Array) < res = acquireResource() try < useResource(res) >finally < releaseResource(res) >>

If the library of language is responsible for the resource releasing, then we call the same as automatic resource management. Such type of feature is relieving us from the remembering the resource which was free. The resource management usually will tied from the scope block. Suppose we are dealing with more than one resource at the same time, they will be released in a good manner.

In the java object which was held the resource and it was eligible for the implementation of resource management which was automatic for a specific interface. Into the kotlin, there is the same concept of the resource holders from which the object will implement either auto closeable or closeable.

How to Use kotlin Resources Function?

For automatically managing the resources many languages have their dedicated construct, sometimes they will be offering a pattern or giving the library method. As per design we can find the method of extension which was used to call use function in standard library.

Below example shows how we can use the function in kotlin resources as follows:

import java.io.File fun main(args: Array) < val kot_fun = FileWriter ("kotlin.txt") kot_fun.use < kot_fun.write ("kotlin") >>

We are invoking the use function on any object which implements the closeable and auto closeable method by using try with the resource. The use method will take the lambda expression, execute it and it will disposes the resource whenever execution will leaving the block either by using exception of by using normally.

In below example we are using variable called writer by creating the closure. The use function will accept the lambda expression with single parameter as follows.

import java.io.File fun main (args: Array) < FileWriter ("kotlin.txt") .use < w ->w.write ("kotlin") > >

We can also use the implicit variable inside into the block.

Below example shows how to use implicit variable inside into the block as follows.

import java.io.File fun main(args: Array) < FileWriter ("kotlin.txt") .use < it.write ("kotlin") >>

Examples of Kotlin try-with-resources

Below are the examples of kotlin try with resources as follows:

Example #1

In below example we are using variable name as ex to define the example of try with resources in kotlin.

import java.io.File fun main(args: Array) < val ex = File("example.txt") ex.bufferedReader().use < println(it.readText()) >>

Example #2

The below example shows how we are using use function by using try with resource in kotlin as follows.

import java.io.File fun main(args: Array) < val example = FileWriter ("example.txt") example.use < example.write ("Kotlin example") >>

FAQ

Given below is the FAQ mentioned:

Q1. How use function is used in kotlin try with resources?

The below code shows how we are using the use function with kotlin try with resources as follows.

import java.io.File val func_use = FileWriter ("use.txt") func_use.use

Q2. What is the syntax of use function in kotlin try with resource?

Inline fun < >, use (block) R (source)

Q3. What is closeable and auto closeable method in kotlin try with resource?

We are defining the use function definition with the closeable method in kotlin. In java auto closeable method does not exist.

Conclusion

A resource is nothing but an object which was closed once in our program is done by using it, for example, socket connection resource. Kotlin try with resources is used to manage the memory in kotlin; kotlin is managing the memory in a very efficient way.

Recommended Articles

This is a guide to Kotlin try-with-resources. Here we discuss the introduction, kotlin try-with-resources management, examples and FAQ. You may also have a look at the following articles to learn more –

25+ Hours of HD Videos
5 Courses
6 Mock Tests & Quizzes
Verifiable Certificate of Completion
Lifetime Access
4.5

92+ Hours of HD Videos
22 Courses
2 Mock Tests & Quizzes
Verifiable Certificate of Completion
Lifetime Access
4.5

83+ Hours of HD Videos
16 Courses
1 Mock Tests & Quizzes
Verifiable Certificate of Completion
Lifetime Access
4.5

KOTLIN Course Bundle — 4 Courses in 1
12+ Hour of HD Videos
4 Courses
Verifiable Certificate of Completion
Lifetime Access
4.5

Источник