En el desarrollo con Kotlin, uno de los desafíos recurrentes es la repetición de lógica dentro de los métodos accesores (getters y setters). Las propiedades dleegadas ofrecen una solución robusta para encapsular comportamientos comunes, permitiendo que la lógica de una propiedad sea gestionada por un objeto externo. Esta técnica no solo mejora la legibilidad, sino que fomenta la reutilización de código en diversos contextos.

Fundamentos de la delegación de propiedades

La sintaxis básica utiliza la palabra clave by, la cual vincula una propiedad con una instancia de una clase que implementa la lógica de acceso. El compilador se encarga de generar los campos necesarios y redirigir las llamadas a los métodos correspondientes del delegado.

val/var <nombre>: <Tipo> by <instancia-delegada>

Observación de cambios con Delegates.observable

La biblioteca estándar de Kotlin incluye herramientas como Delegates.observable, que permite reaccionar a las modificaciones de un valor de forma inmediata. Esto es ideal para sincronizar estados de interfaz de usuario o disparar eventos de persistencia.

Consideremos el siguiente ejemplo donde gestionamos la configuración de una interfaz de audio:

import kotlin.properties.Delegates

class AjustesAudio {
    var nivelVolumen: Int by Delegates.observable(50) { propiedad, anterior, nuevo ->
        if (nuevo !in 0..100) {
            println("Aviso: El valor $nuevo está fuera de rango.")
        } else {
            println("Modificando '${propiedad.name}': de $anterior a $nuevo")
            // Lógica para actualizar el hardware de audio
        }
    }
}

Creación de delegados personalizados

Para escenarios que requieren un control más granular, como la seguridad entre hilos o el manejo de caché, podemos implmeentar nuestras propias interfaces ReadOnlyProperty o ReadWriteProperty.

Delegado para acceso seguro entre hilos

En entornos concurrentes, asegurar que una propiedad se lea y escriba de forma atómica es fundamental. Aquí implementamos un contenedor sincronizado:

import kotlin.reflect.KProperty
import kotlin.properties.ReadWriteProperty

class AccesoSincronizado<T>(valorInicial: T) : ReadWriteProperty<Any?, T> {
    private var contenido = valorInicial
    private val candado = Any()

    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        synchronized(candado) {
            return contenido
        }
    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        synchronized(candado) {
            contenido = value
        }
    }
}

class MonitorRecursos {
    var contadorPeticiones by AccesoSincronizado(0)
}

Delegado con almacenamiento en caché (Memoización)

Cuando el cálculo de un valor es costoso en términos de CPU, un delegado puede almacenar el resultado y permitir su invalidación manual si los datos de origen cambian.

import kotlin.properties.ReadOnlyProperty

class CalculoDiferido<T>(private val operacion: () -> T) : ReadOnlyProperty<Any?, T> {
    private var cache: T? = null

    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return cache ?: operacion().also { cache = it }
    }

    fun limpiar() {
        cache = null
    }
}

class AnalizadorDatos {
    val resultadoComplejo by CalculoDiferido {
        // Simulación de procesamiento pesado
        Thread.sleep(1000)
        "Datos Procesados"
    }
}

Casos de uso prácticos

Simplificación de SharedPreferences en Android

La delegación permite tratar las preferencias del sistema como si fueran variables locales, eliminando el código repetitivo de edición y guardado.

class PreferenciaString(
    private val prefs: SharedPreferences,
    private val clave: String,
    private val defecto: String = ""
) : ReadWriteProperty<Any?, String> {

    override fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return prefs.getString(clave, defecto) ?: defecto
    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        prefs.edit().putString(clave, value).apply()
    }
}

Acceso a elementos del DOM en Kotlin/JS

En el desarrollo web con Kotlin, podemos delegar la búsqueda de elementos HTML para obtener referencias tipadas de manera elegante.

fun <T : HTMLElement> vincularElemento(id: String) = ReadOnlyProperty<Any?, T> { _, _ ->
    document.getElementById(id) as T
}

class PanelControl {
    private val botonEnvio by vincularElemento<HTMLButtonElement>("btn-submit")
    
    fun configurar() {
        botonEnvio.onclick = { println("Formulario enviado") }
    }
}

Buenas prácticas y consideraciones técnicas

Al implementar delegados, es vital tener en cuenta el ciclo de vida de los objetos para evitar fugas de memoria. Si un delegado mantiene una referencia fuerte a un objeto de contexto (como un Activity o un Context), podría impedir que el recolector de basura libere memoria adecuadamente.

Asimismo, la técnica de provideDelegate puede utilizarse para validar el nombre de la propiedad o el estado del objeto antes de crear la instancia final del delegado, lo que añade una capa extra de seguridad en tiempo de compilación.