Делегированные свойства

Ленивые свойства

lazy() — это функция, которая принимает лямбда-выражение и возвращает экземпляр Lazy<T>, который может служить делегатом для реализации ленивого свойства. Первое обращение к get() выполняет лямбда-выражение, переданное в lazy(), и запоминает результат. Последующие обращения к get() просто возвращают сохраненный результат.

val lazyValue: String by lazy {
    println("computed!")
    "Hello"
}

fun main() {
    println(lazyValue)
    println(lazyValue)
}

По умолчанию вычисление ленивых свойств выполняется синхронизированно: значение вычисляется только в одной потоке, но все потоки увидят одно и то же значение. Если синхронизация делегата инициализации не требуется для разрешения одновременного выполнения несколькими потоками, передайте LazyThreadSafetyMode.PUBLICATION в качестве параметра в lazy().

Если вы уверены, что инициализация всегда будет происходить в том же потоке, что и тот, в котором вы используете свойство, вы можете использовать LazyThreadSafetyMode.NONE. Это не влечет никаких гарантий безопасности потоков и связанных с этим накладных расходов.

Наблюдаемые свойства

Delegates.observable() принимает два аргумента: начальное значение и обработчик изменений.

Обработчик вызывается каждый раз, когда вы присваиваете значение свойству (после того, как присвоение было выполнено). Он имеет три параметра: свойство, которому присваивается значение, старое значение и новое значение:

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("$old -> $new")
    }
}

fun main() {
    val user = User()
    user.name = "first"
    user.name = "second"
}

Если вы хотите перехватить присвоения и заблокировать их, используйте vetoable() вместо observable(). Обработчик, переданный в vetoable вызывается до присвоения нового значения свойства.

Правила трансляции для делегированных свойств

Под капотом компилятор Kotlin генерирует вспомогательное свойство для каждого делегированного свойства, а затем делегирует к нему. Например, для свойства prop он генерирует скрытое свойство prop$delegate, а код аксессоров просто делегирует этому дополнительному свойству:

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

Компилятор Kotlin предоставляет всю необходимую информацию о prop в аргументах: первый аргумент this ссылается на экземпляр внешнего класса C, а this::prop — это объект рефлексии типа KProperty, описывающий само prop.

Правила трансляции при делегировании другому свойству

При делегировании другому свойству компилятор Kotlin генерирует непосредственный доступ к указанному свойству. Это означает, что компилятор не генерирует поле prop$delegate. Эта оптимизация помогает экономить память.

Например, рассмотрим следующий код:

class C<Type> {
    private var impl: Type = ...
    var prop: Type by ::impl
}

Аксессоры свойства переменной prop вызывают переменную impl напрямую, минуя getValue и setValue операторы делегированного свойства, и поэтому объект ссылки KProperty не нужен.

Для приведенного выше кода компилятор генерирует следующий код:

class C<Type> {
    private var impl: Type = ...

    var prop: Type
        get() = impl
        set(value) {
            impl = value
        }
    
    fun getProp$delegate(): Type = impl // This method is needed only for reflection
}

Предоставление делегата

Определив оператор provideDelegate, вы можете расширить логику создания объекта, которому делегируется реализация свойства. Если объект, используемый в правой части by, определяет provideDelegate как членскую или расширяющую функцию, эта функция будет вызвана для создания экземпляра делегата свойства.

Одно из возможных применений provideDelegate - проверка согласованности свойства при его инициализации.

Например, чтобы проверить имя свойства перед привязкой, можно написать что-то вроде этого:

class ResourceDelegate<T> : ReadOnlyProperty<MyUI, T> {
    override fun getValue(thisRef: MyUI, property: KProperty<*>): T { ... }
}
    
class ResourceLoader<T>(id: ResourceID<T>) {
    operator fun provideDelegate(
            thisRef: MyUI,
            prop: KProperty<*>
    ): ReadOnlyProperty<MyUI, T> {
        checkProperty(thisRef, prop.name)
        // create delegate
        return ResourceDelegate()
    }

    private fun checkProperty(thisRef: MyUI, name: String) { ... }
}

class MyUI {
    fun <T> bindResource(id: ResourceID<T>): ResourceLoader<T> { ... }

    val image by bindResource(ResourceID.image_id)
    val text by bindResource(ResourceID.text_id)
}

Параметры provideDelegate такие же, как и параметры getValue:

• thisRef должен иметь тот же тип, что и, или быть супертипом, владельца свойства (для расширяемых свойств, это должен быть тип, который расширяется);

• property должен быть типа KProperty<*> или его супертипа.

Метод provideDelegate вызывается для каждого свойства во время создания экземпляра MyUI, и он сразу выполняет необходимую валидацию.

Без этой возможности перехвата связи между свойством и его делегатом, для достижения той же функциональности вам пришлось бы явно передавать имя свойства, что неудобно:

// 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
}

В сгенерированном коде метод provideDelegate вызывается для инициализации вспомогательного свойства prop$delegate. Сравните сгенерированный код для объявления свойства val prop: Type by MyDelegate() с сгенерированным кодом выше (когда метод provideDelegate отсутствует):

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)
    var prop: Type
        get() = prop$delegate.getValue(this, this::prop)
        set(value: Type) = prop$delegate.setValue(this, this::prop, value)
}

Обратите внимание, что метод provideDelegate влияет только на создание вспомогательного свойства и не влияет на код, сгенерированный для геттера или сеттера.

С помощью интерфейса PropertyDelegateProvider из стандартной библиотеки можно создавать поставщиков делегатов без создания новых классов.

val provider = PropertyDelegateProvider { thisRef: Any?, property ->
    ReadOnlyProperty<Any?, Int> {_, property -> 42 }
}
val delegate: Int by provider