Kotlin
प्रत्यायोजित गुण

परिचय

आलसी आरंभीकरण

val foo : Int by lazy { 1 + 1 }
println(foo)

उदाहरण 2 प्रिंट करता है।

अवलोकनीय गुण

var foo : Int by Delegates.observable("1") { property, oldValue, newValue ->
    println("${property.name} was changed from $oldValue to $newValue")
}
foo = 2

उदाहरण प्रिंट्स foo was changed from 1 to 2

मानचित्र समर्थित गुण

val map = mapOf("foo" to 1)
val foo : String by map
println(foo)

उदाहरण प्रिंट 1

कस्टम प्रतिनिधिमंडल

class MyDelegate {
    operator fun getValue(owner: Any?, property: KProperty<*>): String {
        return "Delegated value"
    }
}

val foo : String by MyDelegate()
println(foo)

उदाहरण में Delegated value प्रिंट होता है

डेलीगेट का उपयोग बॉयलरप्लेट को कम करने के लिए एक परत के रूप में किया जा सकता है

कोटलिन की अशक्त प्रकार प्रणाली और WeakReference<T> पर विचार करें WeakReference<T> ।

तो मान लें कि हमें किसी प्रकार के संदर्भ को सहेजना है और हम मेमोरी लीक से बचना चाहते हैं, यहां पर WeakReference आता है।

उदाहरण के लिए इसे लें:

class MyMemoryExpensiveClass {
    companion object {
        var reference: WeakReference<MyMemoryExpensiveClass>? = null

        fun doWithReference(block: (MyMemoryExpensiveClass) -> Unit) {
            reference?.let {
                it.get()?.let(block)
            }
        }
    }

    init {
        reference = WeakReference(this)
    }
}

अब यह सिर्फ एक WeakReference के साथ है। इस बॉयलरप्लेट को कम करने के लिए, हम एक कस्टम प्रॉपर्टी डेलीगेट का उपयोग कर सकते हैं ताकि हम उसकी मदद कर सकें:

class WeakReferenceDelegate<T>(initialValue: T? = null) : ReadWriteProperty<Any, T?> {
    var reference = WeakReference(initialValue)
        private set
    
    override fun getValue(thisRef: Any, property: KProperty<*>): T? = reference.get()
    
    override fun setValue(thisRef: Any, property: KProperty<*>, value: T?) {
        reference = WeakReference(value)
    }
}

तो अब हम चर के साथ लिपटे रहे हैं का उपयोग कर सकते WeakReference बस सामान्य नल चर की तरह!

class MyMemoryExpensiveClass {
    companion object {
        var reference: MyMemoryExpensiveClass? by WeakReferenceDelegate<MyMemoryExpensiveClass>()

        fun doWithReference(block: (MyMemoryExpensiveClass) -> Unit) {
            reference?.let(block)
        }
    }

    init {
        reference = this
    }
}