| Hard Prerequisites |
| IMPORTANT: Please review these prerequisites, they include important information that will help you with this content. |
|
|
There are certain common kinds of properties, that, though we can implement them manually every time we need them, would be very nice to implement once and for all, and put into a library. Examples include
To cover these (and other) cases, Kotlin supports delegated properties:
class Example {
var p: String by Delegate()
}
The syntax is: val/var : by . The expression after by is the delegate, because get() (and set()) corresponding to the property will be delegated to its getValue() and setValue() methods. Property delegates don’t have to implement any interface, but they have to provide a getValue() function (and setValue() — for var’s). For example:
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
}
}
When we read from p that delegates to an instance of Delegate, the getValue() function from Delegate is called, so that its first parameter is the object we read p from and the second parameter holds a description of p itself (e.g. you can take its name). For example:
val e = Example()
println(e.p)
This prints
Example@33a17727, thank you for delegating ‘p’ to me!
Similarly, when we assign to p, the setValue() function is called. The first two parameters are the same, and the third holds the value being assigned:
e.p = "NEW"
This prints
NEW has been assigned to ‘p’ in Example@33a17727. Note that since Kotlin 1.1 you can declare a delegated property inside a function or code block, it shouldn’t necessarily be a member of a class.
The Kotlin standard library provides factory methods for several useful kinds of delegates.
lazy() is a function that takes a lambda and returns an instance of Lazy which can serve as a delegate for implementing a lazy property: the first call to get() executes the lambda passed to lazy() and remembers the result, subsequent calls to get() simply return the remembered result.
val lazyValue: String by lazy {
println("computed!")
"Hello"
}
fun main(args: Array<String>) {
println(lazyValue)
println(lazyValue)
}
This example prints:
computed!
Hello
Hello
By default, the evaluation of lazy properties is synchronized: the value is computed only in one thread, and all threads will see the same value.
If the synchronization of initialization delegate is not required, so that multiple threads can execute it simultaneously, pass LazyThreadSafetyMode.PUBLICATION as a parameter to the lazy() function.
And if you’re sure that the initialization will always happen on a single thread, you can use LazyThreadSafetyMode.NONE mode, which doesn’t incur any thread-safety guarantees and the related overhead.
Delegates.observable() takes two arguments: the initial value and a handler for modifications. The handler gets called every time we assign to the property (after the assignment has been performed). It has three parameters: a property being assigned to, the old value and the new one:
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("<no name>") {
prop, old, new ->
println("$old -> $new")
}
}
fun main(args: Array<String>) {
val user = User()
user.name = "first"
user.name = "second"
}
This example prints:
<no name> -> first
first -> second
If you want to be able to intercept an assignment and “veto” it, use vetoable() instead of observable(). The handler passed to the vetoable is called before the assignment of a new property value has been performed.
One common use case is storing the values of properties in a map. This comes up often in applications like parsing JSON or doing other “dynamic” things. In this case, you can use the map instance itself as the delegate for a delegated property.
class User(val map: Map<String, Any?>) {
val name: String by map
val age: Int by map
}
In this example, the constructor takes a map:
val user = User(mapOf(
"name" to "John Doe",
"age" to 25
))
Delegated properties take values from this map (by the string keys –– names of properties):
println(user.name) // Prints "John Doe"
println(user.age) // Prints 25
This works also for var’s properties if you use a MutableMap instead of read-only Map:
class MutableUser(val map: MutableMap<String, Any?>) {
var name: String by map
var age: Int by map
}
You can declare local variables as delegated properties. For instance, you can make a local variable lazy:
fun example(computeFoo: () -> Foo) {
val memoizedFoo by lazy(computeFoo)
if (someCondition && memoizedFoo.isValid()) {
memoizedFoo.doSomething()
}
}
The memoizedFoo variable will be computed on the first access only. If someCondition fails, the variable won’t be computed at all.
Here we summarize requirements to delegate objects.
For a read-only property (i.e. a val), a delegate has to provide a function named getValue that takes the following parameters:
For a mutable property (a var), a delegate has to additionally provide a function named setValue that takes the following parameters:
getValue() and/or setValue() functions may be provided either as member functions of the delegate class or extension functions. The latter is handy when you need to delegate property to an object which doesn’t originally provide these functions. Both of the functions need to be marked with the operator keyword.
The delegate class may implement one of the interfaces ReadOnlyProperty and ReadWriteProperty containing the required operator methods. These interfaces are declared in the Kotlin standard library:
interface ReadOnlyProperty<in R, out T> {
operator fun getValue(thisRef: R, property: KProperty<*>): T
}
interface ReadWriteProperty<in R, T> {
operator fun getValue(thisRef: R, property: KProperty<*>): T
operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}
Translation Rules Under the hood for every delegated property the Kotlin compiler generates an auxiliary property and delegates to it. For instance, for the property prop the hidden property prop$delegate is generated, and the code of the accessors simply delegates to this additional property:
class C {
var prop: Type by MyDelegate()
}
// this code is generated by the compiler instead:
class C {
private val prop$delegate = MyDelegate()
var prop: Type
get() = prop$delegate.getValue(this, this::prop)
set(value: Type) = prop$delegate.setValue(this, this::prop, value)
}
The Kotlin compiler provides all the necessary information about prop in the arguments: the first argument this refers to an instance of the outer class C and this::prop is a reflection object of the KProperty type describing prop itself.
Note that the syntax this::prop to refer a bound callable reference in the code directly is available only since Kotlin 1.1.
By defining the provideDelegate operator you can extend the logic of creating the object to which the property implementation is delegated. If the object used on the right hand side of by defines provideDelegate as a member or extension function, that function will be called to create the property delegate instance.
One of the possible use cases of provideDelegate is to check property consistency when the property is created, not only in its getter or setter.
For example, if you want to check the property name before binding, you can write something like this:
class ResourceLoader<T>(id: ResourceID<T>) {
operator fun provideDelegate(
thisRef: MyUI,
prop: KProperty<*>
): ReadOnlyProperty<MyUI, T> {
checkProperty(thisRef, prop.name)
// create delegate
}
private fun checkProperty(thisRef: MyUI, name: String) { ... }
}
fun <T> bindResource(id: ResourceID<T>): ResourceLoader<T> { ... }
class MyUI {
val image by bindResource(ResourceID.image_id)
val text by bindResource(ResourceID.text_id)
}
The parameters of provideDelegate are the same as for getValue:
The provideDelegate method is called for each property during the creation of the MyUI instance, and it performs the necessary validation right away.
Without this ability to intercept the binding between the property and its delegate, to achieve the same functionality you’d have to pass the property name explicitly, which isn’t very convenient:
// Checking the property name without "provideDelegate" functionality
class MyUI {
val image by bindResource(ResourceID.image_id, "image")
val text by bindResource(ResourceID.text_id, "text")
}
fun <T> MyUI.bindResource(
id: ResourceID<T>,
propertyName: String
): ReadOnlyProperty<MyUI, T> {
checkProperty(this, propertyName)
// create delegate
}
In the generated code, the provideDelegate method is called to initialize the auxiliary prop$delegate property. Compare the generated code for the property declaration val prop: Type by MyDelegate() with the generated code above (when the provideDelegate method is not present):
class C {
var prop: Type by MyDelegate()
}
// this code is generated by the compiler
// when the 'provideDelegate' function is available:
class C {
// calling "provideDelegate" to create the additional "delegate" property
private val prop$delegate = MyDelegate().provideDelegate(this, this::prop)
val prop: Type
get() = prop$delegate.getValue(this, this::prop)
}
Note that the provideDelegate method affects only the creation of the auxiliary property and doesn’t affect the code generated for getter or setter.