Crear objetos de dominio - SDK de Kotlin

Crear un objeto de reino

Para crear una nueva instancia de RealmObject, crea un nuevo objeto de tipo de objeto realm.

En el siguiente ejemplo, instanciamos un objeto Frog en un bloque realm.write() y luego pasamos el objeto instanciado a copyToRealm() para devolver una instancia administrada:

// Open a write transaction
realm.write {
    // Instantiate a new unmanaged Frog object
    val unmanagedFrog = Frog().apply {
        name = "Kermit"
        age = 42
        owner = "Jim Henson"
    }
    assertFalse(unmanagedFrog.isManaged())
    // Copy the object to realm to return a managed instance
    val managedFrog = copyToRealm(unmanagedFrog)
    assertTrue(managedFrog.isManaged())
    // Work with the managed object ...
}

Crear un objeto incrustado

Para crear una nueva instancia de EmbeddedRealmObject, asigna una instancia de un tipo de objeto incrustado a una propiedad del objeto principal. Esto puede darse en una relación uno a uno, uno a muchos, o inversa, dependiendo de cómo se haya definido el objeto incrustado dentro del tipo de objeto Realm. Para obtener más información, consulta Definir un objeto incrustado.

Los objetos incrustados tienen propiedad estricta con su objeto principal. Después de crear el objeto incrustado,no se puede reasignar a otro objeto principal ni compartirlo entre varios objetos principales.

En el siguiente ejemplo, instanciamos un nuevo objeto Contact con un Address incrustado, que contiene un objeto Contact y un objeto Country incrustado:

realm.write {
    // Instantiate a parent object with one embedded address
    val contact = Contact().apply {
        name = "Kermit"
        address = EmbeddedAddress().apply {
            propertyOwner = Contact().apply { name = "Mr. Frog" }
            street = "123 Pond St"
            country = EmbeddedCountry().apply { name = "United States" }
        }
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(contact)
}

También instanciamos un nuevo objeto Business con una lista de objetos Address incrustados, que también contienen objetos Contact y objetos Country incrustados:

realm.write {
    // Instantiate a parent object with multiple embedded addresses
    val localOffice = EmbeddedAddress().apply {
        propertyOwner = Contact().apply { name = "Michigan J. Frog" }
        street = "456 Lily Pad Ln"
        country = EmbeddedCountry().apply { name = "United States" }
    }
    val remoteOffice = EmbeddedAddress().apply {
        propertyOwner = Contact().apply { name = "Mr. Toad" }
        street = "789 Leaping Frog Ave"
        country = EmbeddedCountry().apply { name = "Ireland" }
    }
    val business = Business().apply {
        name = "Big Frog Corp."
        addresses = realmListOf(localOffice, remoteOffice)
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(business)
}

Crear un objeto asimétrico

A diferencia de otros objetos de Realm,no se utiliza el copyToRealm() método para crearlo. Esto se debe a que los objetos asimétricos son de solo escritura: no se almacenan en el dominio. En su lugar, se utiliza un insert() método de extensión especial para insertarlos en el dominio.

Para crear una nueva AsymmetricRealmObject instancia, cree una instancia de un nuevo objeto de un tipo de objeto asimétrico usando insert().

En el siguiente ejemplo, instanciamos un nuevo objeto WeatherSensor y lo pasamos a insert() dentro de una transacción de escritura:

// Open a write transaction
realm.write {
    // Create a new asymmetric object
    val weatherSensor = WeatherSensor().apply {
        deviceId = "WX1278UIT"
        temperatureInFarenheit = 6.7F
        barometricPressureInHg = 29.65F
        windSpeedInMph = 2
    }
    // Insert the object into the realm with the insert() extension method
    insert(weatherSensor)
// WeatherSensor object is inserted into the realm, then synced to the
// App Services backend. You CANNOT access the object locally because it's
// deleted from the local realm after sync is complete.
}

Una vez insertado, el objeto asimétrico se sincroniza con el backend de App Services y la base de datos Atlas vinculada.No se puede acceder a los datos administrados localmente, añadirlos o eliminarlos de un dominio, ni consultarlos. Para obtener información sobre cómo usar objetos asimétricos en su aplicación, consulte "Transmitir datos a Atlas - SDK de Kotlin".

Crear una propiedad RealmInstant (marca de tiempo)

Para crear una nueva instancia de objeto con una propiedad RealmInstant, cree una instancia de un objeto y pase un valor inicial a la RealmInstant propiedad usando:

• RealmInstant.from(): los segundos y nanosegundos desde la época de Unix

• RealmInstant.now(): los segundos y nanosegundos desde la época de Unix hasta ahora

Para obtener más información sobre el RealmInstant tipo, consulte RealmInstant (marca de tiempo).

En el siguiente ejemplo, instanciamos un nuevo objeto Frog con una propiedad birthdate y pasamos un valor inicial a RealmInstant.from():

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmInstant property
    val frog = Frog().apply {
        name = "Kermit"
        // Set an initial value with RealmInstant.from() or RealmInstant.now()
        birthdate = RealmInstant.from(1_577_996_800, 0)
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

Crear una propiedad MutableRealmInt (Counter)

Para crear una nueva instancia de objeto con una propiedad MutableRealmInt, cree una instancia de un objeto y pase un valor inicial a la MutableRealmInt propiedad mediante MutableRealmInt.create(). Para obtener más información sobre el MutableRealmInt tipo, consulte MutableRealmInt (Counter).

En el siguiente ejemplo, instanciamos un nuevo objeto Frog con una propiedad fliesEaten y pasamos un valor inicial a MutableRealmInt.create():

realm.write {
    // Instantiate a new unmanaged Frog object with a MutableRealmInt property
    val frog = Frog().apply {
        name = "Michigan J. Frog"
        // Set an initial value with MutableRealmInt.create()
        fliesEaten = MutableRealmInt.create(200)
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

Crear una propiedad RealmAny (Mixta)

Para crear una nueva instancia de objeto con una propiedad polimórfica RealmAny, cree una instancia de un objeto y pase un valor inicial de un tipo compatible a la RealmAny propiedad mediante RealmAny.create(). Para obtener una lista de los tipos de valores que RealmAny puede contener, consulte RealmAny (Mixto).

En el siguiente ejemplo, instanciamos un nuevo objeto Frog con una lista favoriteThings de tipo RealmAny y pasamos los valores iniciales a RealmAny.create():

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmAny property
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial values with RealmAny.create()
        favoriteThings = realmListOf(
            RealmAny.create(42),
            RealmAny.create("rainbows"),
            RealmAny.create(Frog().apply {
                name = "Kermit Jr."
            })
        )
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

Después de crear el objeto, debe conocer el tipo de valor almacenado para trabajar con la propiedad RealmAny. Para aprender cómo actualizar las propiedades RealmAny después de crear el objeto, consulta Actualiza una propiedad RealmAny (Mixta).

Crear una RealmList

Para crear una nueva instancia de objeto con una propiedad RealmList, cree una instancia de un objeto y pase cualquier valor de un tipo compatible a la RealmList propiedad. Para obtener una lista de los tipos de valores que RealmList puede contener, consulte RealmList.

Puedes instanciar una lista no administrada con realmListOf() o pasarle elementos mediante list.add(), list.addAll() o list.set(). La lista no se administra hasta que la copies al dominio.

En el siguiente ejemplo, instanciamos un nuevo objeto Frog con valores iniciales para varias propiedades RealmList:

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmList property
    val frog = Frog().apply {
        name = "Kermit"
        // Set values for each unmanaged list
        favoritePonds.addAll(realmListOf(
            Pond().apply { name = "Picnic Pond" },
            Pond().apply { name = "Big Pond" }
        ))
        favoriteForests.add(EmbeddedForest().apply { name = "Hundred Acre Wood" })
        favoriteWeather = realmListOf("rain", "snow")
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

Crear una propiedad RealmSet

Para crear una nueva instancia de objeto con una propiedad RealmSet, cree una instancia de un objeto y pase cualquier valor de un tipo compatible a la RealmSet propiedad. Para obtener una lista de los tipos válidos que RealmSet puede contener, consulte RealmSet.

Puedes instanciar un conjunto no administrado con realmSetOf() o pasarle elementos mediante set.add() o set.addAll(). El conjunto no se administra hasta que lo copies al dominio.

En el siguiente ejemplo, instanciamos un nuevo objeto Frog con valores iniciales para las propiedades establecidas favoriteSnacks y favoriteWeather:

realm.write {
    // Instantiate a new unmanaged Frog object with RealmSet properties
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial values to each unmanaged set
        favoriteSnacks.addAll(setOf(
            Snack().apply { name = "flies" },
            Snack().apply { name = "crickets" },
            Snack().apply { name = "worms" }
        ))
        favoriteWeather.add("rain")
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

Crear una propiedad de diccionario

Para crear una nueva instancia de objeto con una propiedad RealmDictionary, cree una instancia de un objeto y pase cualquier par clave-valor de un tipo compatible a la RealmDictionary propiedad. RealmDictionary solo acepta una String clave, pero los valores pueden ser de tipos distintos de cadenas. Para obtener una lista de tipos válidos, consulte RealmMap/RealmDictionary.

Puedes instanciar un diccionario no administrado con realmDictionaryOf() o realmDictionaryEntryOf(). También puedes pasar valores clave con put() o putAll(). El diccionario no se administra hasta que lo copies al dominio.

En el siguiente ejemplo, instanciamos un nuevo objeto Frog con valores clave iniciales para varias propiedades del diccionario:

realm.write {
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial key-values to each unmanaged dictionary
        favoriteFriendsByPond = realmDictionaryOf(
            "Picnic Pond" to Frog().apply { name = "Froggy Jay" },
            "Big Pond" to Frog().apply { name = "Mr. Toad" }
        )
        favoriteTreesInForest["Maple"] = EmbeddedForest().apply {
            name = "Hundred Acre Wood"
        }
        favoritePondsByForest.putAll(
            mapOf(
                "Silver Pond" to "Big Forest",
                "Big Lake" to "Elm Wood",
                "Trout Pond" to "Sunny Wood"
            )
        )
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

Realm no permite el uso de caracteres . o $ en las claves de mapa. Puedes usar la codificación y decodificación porcentual para almacenar una clave de mapa que contenga uno de estos caracteres no permitidos.

// Percent encode . or $ characters to use them in map keys
val mapKey = "Hundred Acre Wood.Northeast"
val encodedMapKey = "Hundred Acre Wood%2ENortheast"

Crea una relación de uno a uno

Para crear una nueva instancia de objeto con una propiedad de relación de uno a uno, cree una instancia de ambos objetos y pase el objeto referenciado a la propiedad de relación.

En el siguiente ejemplo, instanciamos un nuevo objeto Frog con una propiedad favoritePond que referencia un objeto Pond y una propiedad bestFriend que referencia otro objeto Frog:

realm.write {
    // Instantiate a new unmanaged Frog object with to-one
    // relationship with a Realm object
    val frog = Frog().apply {
        name = "Kermit"
        age = 12
        favoritePond = Pond().apply { name = "Picnic Pond" }
        bestFriend = Frog().apply { name = "Froggy Jay" }
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

Crear una relación de muchos

Para crear una nueva instancia de objeto con una propiedad de relación de varios, cree una instancia de todos los objetos y pase cualquier objeto referenciado a la propiedad de colección de relaciones.

En el siguiente ejemplo, instanciamos un nuevo objeto Forest con una propiedad frogsThatLiveHere que hace referencia a un conjunto de Frog objetos y una propiedad nearByPonds que hace referencia a una lista de Pond objetos:

realm.write {
    // Instantiate a new unmanaged Forest object with to-many
    // relationship with multiple Realm objects
    val forest = Forest().apply {
        name = "Froggy Forest"
        frogsThatLiveHere = realmSetOf(
            Frog().apply { name = "Kermit" },
            Frog().apply { name = "Froggy Jay" }
        )
        nearbyPonds = realmListOf(
            Pond().apply { name = "Small Picnic Pond" },
            Pond().apply { name = "Big Pond" }
        )
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(forest)
}

Crear una relación inversa

Para crear una nueva instancia de objeto con una propiedad de relación inversa, cree una instancia del objeto padre y pase cualquier objeto hijo referenciado a la propiedad de colección de vínculo de retroceso.

En el siguiente ejemplo, se instanciará un objeto User nuevo con una propiedad de vínculos inversos posts que hace referencia a una lista de objetos Post:

realm.write {
    // Instantiate a new unmanaged User object with to-many
    // relationship with multiple Realm objects
    val post1 = Post().apply {
        title = "Forest Life"
    }
    val post2 = Post().apply {
        title = "Top Ponds of the Year!"
    }
    val user = User().apply {
        name = "Kermit"
        posts = realmListOf(post1, post2)
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(user)
}

Después de crear el objeto, puede acceder a la propiedad de colección de vínculos de retroceso para obtener los objetos secundarios, pero no puede modificar directamente el vínculo de retroceso. Para obtener más información, consulte Actualizar una relación inversa.