Stabilität in der Funktion „Schreiben“

Bei der Funktion „Compose“ werden Typen entweder als stabil oder instabil eingestuft. Ein Typ ist stabil, wenn er unveränderlich ist oder wenn Compose erkennen kann, ob sein Wert sich zwischen Neuzusammensetzungen geändert hat. Ein Typ ist instabil, wenn „Compose“ nicht weiß, ob sich sein Wert zwischen Neuzusammensetzungen geändert hat.

Compose verwendet die Stabilität der Parameter einer zusammensetzbaren Funktion, um zu bestimmen, ob die zusammensetzbare Funktion bei der Neuzusammensetzung übersprungen werden kann:

  • Stabile Parameter:Wenn eine zusammensetzbare Funktion stabile Parameter hat, die sich nicht geändert haben, wird sie von der Funktion „Compose“ übersprungen.
  • Instabile Parameter:Wenn eine zusammensetzbare Funktion instabile Parameter hat, wird sie bei der Funktion „Compose“ immer neu zusammengesetzt, wenn die übergeordnete Komponente neu zusammengesetzt wird.

Wenn Ihre Anwendung viele unnötig instabile Komponenten enthält, die von Compose immer neu zusammengesetzt werden, treten möglicherweise Leistungsprobleme und andere Probleme auf.

In diesem Dokument wird beschrieben, wie Sie die Stabilität Ihrer Anwendung erhöhen können, um die Leistung und die Nutzerfreundlichkeit insgesamt zu verbessern.

Unveränderliche Objekte

Die folgenden Snippets verdeutlichen die allgemeinen Prinzipien für Stabilität und Neuzusammensetzung.

Die Contact-Klasse ist eine unveränderliche Datenklasse. Das liegt daran, dass alle Parameter Primitive sind, die mit dem Schlüsselwort val definiert sind. Nachdem Sie eine Instanz von Contact erstellt haben, können Sie den Wert der Attribute des Objekts nicht mehr ändern. In diesem Fall würden Sie ein neues -Objekt erstellen.

data class Contact(val name: String, val number: String)

Die zusammensetzbare Funktion ContactRow hat einen Parameter vom Typ Contact.

@Composable
fun ContactRow(contact: Contact, modifier: Modifier = Modifier) {
   var selected by remember { mutableStateOf(false) }

   Row(modifier) {
      ContactDetails(contact)
      ToggleButton(selected, onToggled = { selected = !selected })
   }
}

Überlegen Sie, was passiert, wenn der Nutzer auf die Ein/Aus-Schaltfläche klickt und sich der Status selected ändert:

  1. Compose wertet aus, ob der Code in ContactRow neu zusammengesetzt werden soll.
  2. Dabei wird festgestellt, dass das einzige Argument für ContactDetails vom Typ Contact ist.
  3. Da Contact eine unveränderliche Datenklasse ist, wird bei Compose sichergestellt, dass sich keines der Argumente für ContactDetails geändert hat.
  4. Die Funktion „Compose“ wird deshalb übersprungen und ContactDetails wird nicht neu erstellt.
  5. Andererseits haben sich die Argumente für ToggleButton geändert und bei der Funktion „Compose“ wird diese Komponente neu zusammengesetzt.

Veränderliche Objekte

Im vorherigen Beispiel wird ein unveränderliches Objekt verwendet. Es ist jedoch möglich, ein änderbares Objekt zu erstellen. Sehen Sie sich das folgende Snippet an:

data class Contact(var name: String, var number: String)

Da jeder Parameter von Contact jetzt ein var ist, ist die Klasse nicht mehr unveränderlich. Wenn sich die Eigenschaften ändern, wird die Funktion „Compose“ nicht mehr erkannt. Das liegt daran, dass in Composer nur Änderungen an Compose-State-Objekten nachverfolgt werden.

Compose betrachtet eine solche Klasse als instabil. Bei der Funktion „Compose“ wird die Neuzusammensetzung instabiler Klassen nicht übersprungen. Wenn also Contact auf diese Weise definiert wäre, würde ContactRow im vorherigen Beispiel bei jeder Änderung von selected neu zusammengesetzt werden.

Implementierung in Compose

Es kann hilfreich, wenn auch nicht entscheidend sein, zu berücksichtigen, wie genau die Funktion „Compose“ bestimmt, welche Funktionen bei der Neuzusammensetzung übersprungen werden sollen.

Wenn der Compiler Compose für Ihren Code ausgeführt wird, werden alle Funktionen und Typen mit einem von mehreren Tags gekennzeichnet. Diese Tags spiegeln wider, wie die Funktion oder der Typ bei der Neuzusammensetzung in Compose verarbeitet wird.

Funktionen

Mit der Funktion „Compose“ können Sie Funktionen als skippable oder restartable markieren. Beachten Sie, dass eine Funktion möglicherweise als eine, beide oder keine der folgenden Funktionen gekennzeichnet wird:

  • Überspringbar: Wenn der Compiler eine zusammensetzbare Funktion als überspringbar markiert, kann sie bei der Neuzusammensetzung von der Funktion „Compose“ übersprungen werden, sofern alle Argumente mit den vorherigen Werten übereinstimmen.
  • Neu zusammensetzbar: Eine zusammensetzbare Funktion, die neu zusammensetzbar ist, dient als „Bereich“, in dem die Neuzusammensetzung beginnen kann. Mit anderen Worten, die Funktion kann ein Einstiegspunkt sein, an dem das Compose mit der neuen Ausführung von Code zur Neuzusammensetzung nach Statusänderungen beginnen kann.

Typen

Mit der Funktion „Compose“ werden Typen als unveränderlich oder stabil gekennzeichnet. Jeder Typ ist einer oder der andere:

  • Unveränderlich: Compose markiert einen Typ als unveränderlich, wenn sich der Wert seiner Eigenschaften nie ändern kann und alle Methoden referenziell transparent sind.
    • Beachten Sie, dass alle primitiven Typen als unveränderlich markiert sind. Dazu gehören String, Int und Float.
  • Stabil: Gibt einen Typ an, dessen Eigenschaften sich nach der Erstellung ändern können. Sollten sich diese Attribute während der Laufzeit ändern, werden diese Änderungen in Compose erkannt.

Stabilität der Fehlerbehebung

Wenn Ihre Anwendung eine zusammensetzbare Funktion umsetzt, deren Parameter sich nicht geändert haben, prüfen Sie zuerst die Definition auf Parameter, die eindeutig änderbar sind. Bei der Funktion „Compose“ wird eine Komponente immer neu zusammengesetzt, wenn Sie einen Typ mit var-Attributen oder eine val-Property übergeben, die einen bekannten instabilen Typ verwendet.

Ausführliche Informationen zur Diagnose komplexer Stabilitätsprobleme in Composer finden Sie in der Anleitung zur Fehlerbehebung bei Stabilitätsproblemen.

Stabilitätsprobleme beheben

Informationen dazu, wie Sie die Stabilität der Implementierung von „Compose“ erhöhen, finden Sie unter Stabilitätsprobleme beheben.

Zusammenfassung

Insgesamt ist Folgendes zu beachten:

  • Parameter: Compose bestimmt die Stabilität der einzelnen Parameter Ihrer zusammensetzbaren Funktionen und damit bestimmen, welche zusammensetzbaren Funktionen bei der Neuzusammensetzung übersprungen werden sollen.
  • Sofortige Fehlerbehebungen: Wenn Sie feststellen, dass die zusammensetzbare Funktion nicht übersprungen wird und ein Leistungsproblem verursacht wird, sollten Sie zuerst die offensichtlichen Ursachen für Instabilität wie var-Parameter prüfen.
  • Compiler-Berichte: Mithilfe der Compiler-Berichte können Sie ermitteln, welche Stabilität über Ihre Klassen abgeleitet wird.
  • Sammlungen: Compose betrachtet Sammelklassen wie List, Set und Map immer als instabil. Dies liegt daran, dass nicht garantiert werden kann, dass sie unveränderlich sind. Sie können stattdessen unveränderliche Kotlinx-Sammlungen verwenden oder Ihre Klassen als @Immutable oder @Stable annotieren.
  • Andere Module: Compose betrachtet immer instabil, wo sie von Modulen stammen, in denen der Compose-Compiler nicht ausgeführt wird. Umschließen Sie die Klassen bei Bedarf in UI-Modellklassen.

Weitere Informationen