Codeoptimierung

Da sich Canvas-Apps weiterentwickeln, um unterschiedliche Geschäftsanforderungen zu erfüllen, ist es entscheidend, die Leistung optimal zu halten. Die Datenverarbeitung, das Design der Benutzeroberfläche und die App-Funktionalität erfordern einen sorgfältigen Ansatz zur Codeoptimierung.

Da Canvas-Apps komplexer werden, können Sie Probleme mit dem Abrufen von Daten, der Formelkomplexität und der Renderinggeschwindigkeit haben. Verwenden Sie einen systematischen Ansatz zur Codeoptimierung, um eine starke Funktionalität mit einer reaktionsfähigen Benutzeroberfläche zu ausgleichen.

Optimierung der Power Fx-Formel

Dieser Abschnitt enthält bewährte Methoden zum Optimieren von Power Fx-Formeln.

Funktion „With“

Die With-Funktion, wertet eine Formel für einen einzelnen Datensatz aus. Die Formel kann einen Wert berechnen und/oder Aktionen ausführen, wie das Ändern von Daten oder das Arbeiten mit einer Verbindung. Verwenden Sie With, um die Lesbarkeit komplexer Formeln durch Aufteilung in kleinere benannte Unterformeln zu verbessern. Diese benannten Werte wirken wie einfache lokale Variablen, die auf den Umfang der With beschränkt sind. With ist besser als Kontext oder globale Variablen, da sie eigenständig, leicht zu verstehen und in jedem deklarativen Formelkontext funktioniert. Erfahren Sie mehr über die With-Funktion.

nebenläufige Funktion

Mit Concurrent der Funktion können mehrere Formeln in derselben Eigenschaft gleichzeitig ausgewertet werden, wenn sie Connector- oder Dataverse-Aufrufe haben. Normalerweise werden mehrere Formeln gleichzeitig ausgewertet, wenn Sie sie mit dem ; Operator (Semikolon) verketten. Mit Concurrent wertet die App alle Formeln in einer Eigenschaft gleichzeitig aus, auch nachdem der Operator ; verwendet wurde. Diese Parallelität bedeutet, dass Benutzer weniger Zeit für Ergebnisse warten. Wenn Datenaufrufe bis zum Abschluss der vorherigen Aufrufe nicht gestartet wurden, wartet die App auf die Summe aller Anforderungszeiten. Wenn die Datenaufrufe zur selben Zeit beginnen, wartet die App nur auf die längste Anforderungszeit. Erfahren Sie mehr über die Gleichzeitige Funktion.

Concurrent(
    ClearCollect(colAccounts1, Accounts),
    ClearCollect(colUsers1, Users),
    ClearCollect(colEnvDef1, 'Environment Variable Definitions'),
    ClearCollect(colEnvVal1, 'Environment Variable Values')
);

Koaleszenzfunktion

Die Coalesce-Funktion wertet ihre Argumente der Reihe nach aus und gibt den ersten Wert zurück, der nicht leer oder eine leere Zeichenfolge ist. Verwenden Sie diese Funktion, um einen leeren Wert oder eine leere Zeichenfolge mit einem anderen Wert zu ersetzen, während nicht-leere Werte und Zeichenfolgen unverändert bleiben. Sind alle Argumente leer oder hat es leere Zeichenfolgen, gibt die Funktion leer zurück. Coalesce ist eine gute Möglichkeit, leere Zeichenfolgen in leere Werte zu konvertieren. Erfahren Sie mehr über die Coalesce-Funktion.

Dieses Beispiel erfordert, dass sowohl value1 als auch value2 zweimal ausgewertet werden.

If(Not IsBlank(value1), value1, Not IsBlank(value2), value2)

Diese Funktion kann reduziert werden auf:

Coalesce(value1, value2)

IsMatch-Funktion

Die IsMatch-Funktion prüft, ob eine Textzeichenfolge mit einem Muster übereinstimmt, das normale Zeichen, vordefinierte Muster oder einen regulären Ausdruck enthält. Erfahren Sie mehr über die IsMatch-Funktion.

Diese Formel entspricht beispielsweise einer US-amerikanischen Sozialversicherungsnummer:

IsMatch(TextInput1.Text, "\d{3}-\d{2}-\d{4}")

Erklärung des regulären Ausdrucks:

• \\d entspricht einer Ziffer (0 bis 9).

• {3} Gibt an, dass das vorangehende Ziffernmuster (\d) genau dreimal vorkommen soll.

• - entspricht dem Bindestrichzeichen.

• {2} Gibt an, dass das vorangehende Ziffernmuster (\d) genau zwei Mal vorkommen soll.

• {4} Gibt an, dass das vorangehende Ziffernmuster (\d) genau viermal vorkommen soll.

Weitere Beispiele für IsMatch:

IsMatch(TextInput1.Text, "Hello World")
IsMatch(TextInput1\_2.Text, "(?!^\[0-9\]\\\*$)(?!^\[a-zA-Z\]\\\*$)(\[a-zA-Z0-9\]{8,10})")

App-OnStart optimieren

Die OnStart Eigenschaft für Canvas-Apps spielt eine wichtige Rolle beim Definieren von Aktionen, die beim Starten der App auftreten. Mit dieser Eigenschaft können App-Entwickler globale Initialisierungsaufgaben ausführen, Variablen einrichten und Aktionen durchführen, die während des Startvorgangs der App nur einmal erfolgen sollten. Um die OnStart Eigenschaft zu verstehen und effektiv zu nutzen, um responsive und effiziente Canvas-Apps zu erstellen.

Optimieren Sie die App.OnStart Funktion, indem Sie Variablensetups zu benannten Formeln migrieren. Benannte Formeln, insbesondere diejenigen, die frühzeitig im App-Lebenszyklus konfiguriert wurden, sind vorteilhaft. Diese Formeln handhaben die Initialisierung von Variablen basierend auf Datenaufrufen und sorgen für eine sauberere und besser organisierte Struktur für Ihren Code. Weitere Informationen finden Sie unter "Erstellen großer und komplexer Canvas-Apps".

Startbildschirm

** Wenn App.OnStart einen Navigate Funktionsaufruf enthält, selbst wenn er sich in einer If Funktion befindet und selten aufgerufen wird, muss die App die Ausführung von App.OnStart abschließen, bevor der erste Bildschirm der App angezeigt wird.  App.StartScreen ist eine deklarative Methode, um anzugeben, welcher Bildschirm zuerst angezeigt werden soll, und es blockiert keine Optimierungen.

Durch Festlegen der StartScreen-Eigenschaft wird der erste Bildschirm angezeigt, bevor App.OnStart abgeschlossen wird. App.StartScreen deklariert, welches Bildschirmobjekt zuerst angezeigt werden soll, ohne dass eine Vorverarbeitung erforderlich ist.

Anstatt Code wie diesen zu schreiben:

App.OnStart = Collect(OrdersCache, Orders);
If(Param("AdminMode") = "1", Navigate(AdminScreen), Navigate(HomeScreen))

Ändert den Code auf:

App.OnStart = Collect(OrdersCache, Orders);
App.StartScreen = If(Param("AdminMode") = "1", AdminScreen, HomeScreen)

Weitere Informationen: App.StartScreen: eine deklarative Alternative zur Navigation in "App.OnStart".

Benannte Formeln

Benannte Formeln sind statische Größen oder Konstanten, die in App.Formulas definiert werden können. Einmal in App.Formulas deklariert, können sie überall in der App verwendet werden, und ihre Werte bleiben immer auf dem neuesten Stand. Mit benannten Formeln in Power Apps können Sie Werte oder Wertesätze definieren, die die Plattform automatisch verwaltet und aktualisiert. Diese Funktionalität verschiebt die Verantwortung für die Wertberechnung und Wartung vom Entwickler an Power Apps, um den Entwicklungsprozess zu optimieren. Benannte Formeln in Power Apps sind ein leistungsfähiges Feature, das die Leistung und Wartung der App erheblich verbessern kann.

Benannte Formeln helfen auch beim Deklarieren von App-Themen. Beim Erstellen von Unternehmens-Apps möchten Sie häufig, dass die App allgemeine Designs aufweist, die ein einheitliches Aussehen und eine einheitliche Benutzeroberfläche bieten. Um ein Design zu erstellen, müssen Sie zehn bis Hunderte von Variablen in App.OnStartdeklarieren. Diese Deklaration erhöht die Codelänge und die Initialisierungszeit der App.

Moderne Steuerelemente können auch bei der Themengestaltung erheblich hilfreich sein und dazu beitragen, die vom Kunden geschriebene Logik zur Handhabung der Themen zu reduzieren. Moderne Steuerelemente befinden sich derzeit in der Vorschauphase.

Sie können z. B. den folgenden Code von App.OnStart nach App.Formulas verschieben, wodurch die Startzeit bei globalen Variablendeklarationen reduziert wird.

Set(BoardDark, RGBA(181,136,99, 1));
Set(BoardSelect, RGBA(34,177,76,1));
Set(BoardRowWidth, 10);                      // expected 8 plus two guard characters for regular expressions.
Set(BoardMetadata, 8 \* BoardRowWidth + 1);   // which player is next, have pieces moved for castling rules, etc.
Set(BoardBlank, "----------------------------------------------------------------\_00000000000000");
Set(BoardClassic, "RNBQKBNR\_\_PPPPPPPP------------------------\_--------\_\_pppppppp\_\_rnbqkbnr\_\_0000000000");

Sie können den Code wie folgt nach App.Formulas verschieben:

BoardSize = 70;
BoardLight = RGBA(240,217,181, 1);
BoardDark = RGBA(181,136,99, 1);
BoardSelect = RGBA(34,177,76,1);
BoardRowWidth = 10;                      // expected 8 plus two guard characters for regular expressions
BoardMetadata = 8 \* BoardRowWidth + 1;   // which player is next, have pieces moved for castling rules, etc.
BoardBlank = "----------------------------------------------------------------\_00000000000000";
BoardClassic = "RNBQKBNR\_\_PPPPPPPP------------------------\_--------\_\_pppppppp\_\_rnbqkbnr\_\_0000000000";

Ein weiteres Beispiel ist die Einstellung Lookups. Hier ist eine Änderung in einer Lookup Formel erforderlich, um die Benutzerinformationen aus Office 365 anstelle von Dataverse abzurufen. Sie müssen die Änderung nur an einer Stelle vornehmen, ohne den Code überall zu ändern.

UserEmail = User().Email;
UserInfo = LookUp(Users, 'Primary Email' = User().Email);
UserTitle = UserInfo.Title;
UserPhone = Switch(UserInfo.'Preferred Phone', 'Preferred Phone (Users)'.'Mobile Phone', UserInfo.'Mobile Phone',
UserInfo.'Main Phone');

Diese Formeln verkörpern die Essenz der Berechnung. Sie formulieren den Prozess zur Bestimmung von UserEmail, UserInfo, UserTitle und UserPhone basierend auf anderen Werten. Diese Logik ist gekapselt, was eine umfassende Nutzung in der gesamten App ermöglicht und an einer einzigen Stelle geändert werden kann. Die Anpassungsfähigkeit erstreckt sich auf den Wechsel von der Dataverse Benutzertabelle zum Office 365 Connector, ohne dass Änderungen an in der App verstreuten Formeln erforderlich sind.

Ein anderer Ansatz ist die Optimierung von countRows.

varListItems = CountRows(SampleList)

Mit der Set Funktion müssen Sie die Variable varListItems mit der anfänglichen Anzahl von Zeilen in der Beispielliste initialisieren und nach dem Hinzufügen oder Entfernen der Listenelemente erneut festlegen. Bei benannten Formeln wird die Variable bei einer Änderung der varListItems Daten automatisch aktualisiert.

Benannte Formeln in der App.Formulas Eigenschaft bieten einen flexibleren und deklarativeren Ansatz zum Verwalten von Werten und Berechnungen in der gesamten App. Sie bieten Vorteile hinsichtlich zeitlicher Unabhängigkeit, automatischer Aktualisierungen, Wartungsfreundlichkeit und unveränderlicher Definitionen im Vergleich zu ausschließlichem Vertrauen auf App.OnStart.

Benutzerdefinierte Funktionen

Mit benutzerdefinierten Funktionen in Power Apps Studio können Sie eigene benutzerdefinierte Funktionen erstellen.

Definieren Sie eine Formel unter App.Formulas wie folgt:

FunctionName(Parameter1:DataType1, Parameter2:DataType2):OutputDataType = Formula

Der Code funktioniert wie folgt:

• FunctionName ruft die Funktion auf.

• Parameter ist der Name der Eingabe. Sie können eine oder mehrere Eingaben einschließen.

• DataType ist der Datentyp, mit dem das an die Funktion übergebene Argument übereinstimmen muss. Verfügbare Datentypen sind boolean, Color, Date, Datetime, Dynamic, GUID, Hyperlink, Text und Time.

• OutputDataType ist der Datentyp für die Ausgabe der Funktion.

• Formula ist die Ausgabe der Funktion.

Wird IfError verwendet, um die Fehlerbehandlung in der definierten Funktion zu implementieren:

// Function to calculate the area of a circle based on the radius
calcAreaOfCircle(radius: Number): Number = 
    IfError(Pi() * radius * radius, 0);

Rufen Sie die definierte Funktion aus einem Text- oder Bezeichnungssteuerelement auf.

calcAreaOfCircle(Int(*TextInput1*.Text))

Optimieren Sie Variablen

Variablen definieren und legen lokale und globale Werte fest, die Sie in Ihrer gesamten App verwenden. Sie sind zwar praktisch, können aber die Effizienz Ihrer App beeinträchtigen, wenn Sie zu viele Variablen verwenden.

Im folgenden Beispiel wird veranschaulicht, wie für jedes Attribut eines Objekts eine Variable festgelegt wird, die für jede Eigenschaft Set verwendet werden muss.

Set(varEmpName, Office365Users.MyProfile().DisplayName);
Set(varEmpCity, Office365Users.MyProfile().City);
Set(varEmpPhone, Office365Users.MyProfile().BusinessPhones);
Set(varEmpUPN, Office365Users.MyProfile().UserPrincipalName);
Set(varEmpMgrName, Office365Users.ManagerV2(varEmpUPN).DisplayName);

Ein effizienterer Ansatz besteht darin, die Eigenschaft nur dann zu verwenden, wenn Sie sie benötigen:

Set(varEmployee, Office365Users.MyProfile())
"Welcome " & varEmployee.DisplayName

Verwenden Sie Kontextvariablen und globale Variablen mit Bedacht. Wenn der Umfang einer Variablen über einen einzelnen Bildschirm hinausgeht, verwenden Sie globale Variablen anstelle von Kontextvariablen.

Zu viele ungenutzte Variablen erhöhen die Speicherauslastung und können die App-Initialisierung verlangsamen. Für diese Variablen werden Ressourcen zugewiesen, auch wenn Sie sie nicht verwenden. Ungenutzte Variablen erhöhen auch die Komplexität der Logik Ihrer App. Sorgen Sie dafür, dass Ihre Power App sauber und organisiert ist, um eine bessere Leistung und eine einfachere Entwicklung zu erzielen.

Sammlungen optimieren

Sammlungen sind temporäre Datenspeicherstrukturen, die Sie zum Speichern und Bearbeiten von Daten in einer Power Apps App verwenden. Sammlungen können jedoch leistungseinbußen verursachen. Schränken Sie die Verwendung von Sammlungen ein und verwenden Sie sie nur bei Bedarf.

// Use this pattern
ClearCollect(colErrors, {Text: gblErrorText, Code: gblErrorCode});

// Do not use this pattern
Clear(colErrors);
Collect(colErrors, {Text: gblErrorText, Code: gblErrorCode});

Um Datensätze in einer lokalen Sammlung zu zählen, verwenden Sie CountIf anstelle von Count(Filter()).

Berücksichtigen Sie diesen Ansatz beim Arbeiten mit Sammlungen:

• Begrenzen Sie die Größe und Anzahl der Sammlungen. Da Sammlungen in der App lokal sind, werden sie im Speicher des mobilen Geräts gespeichert. Je mehr Daten die Sammlungen enthalten oder je mehr Sammlungen Sie verwenden, desto schlechter ist die Leistung. Verwenden Sie die ShowColumns Funktion, um nur bestimmte Spalten abzurufen. Fügen Sie die Filter Funktion hinzu, um nur relevante Daten abzurufen.

  Die folgende Beispielfunktion gibt das gesamte Dataset zurück:

  ClearCollect(colDemoAccount, Accounts);
  

  Vergleichen Sie diese Funktion mit dem folgenden Code, der nur bestimmte Datensätze und Spalten zurückgibt:

  ClearCollect(colAcc,
    ShowColumns(
      Filter(Accounts, !IsBlank('Address 1: City')),
      "name","address1_city"))
  

  Dieses Beispiel gibt den folgenden Datensatz zurück:

  

• Legen Sie eine Aktualisierungshäufigkeit für die Datenquelle fest. Wenn Sie der Sammlung neue Datensätze hinzufügen, aktualisieren Sie sie, oder sammeln Sie sie, um die neuen oder geänderten Datensätze abzurufen. Wenn mehrere Benutzer Ihre Datenquelle aktualisieren, aktualisieren Sie die Sammlung, um die neuen oder geänderten Datensätze abzurufen. Mehr Aktualisierungsaufrufe bedeuten mehr Interaktion mit dem Server.

Zwischenspeichern von Daten in Sammlungen und Variablen

Eine Sammlung ist eine Tabellenvariable, die Datenzeilen und -spalten speichert, nicht nur ein einzelnes Datenelement. Sammlungen sind aus zwei Hauptgründen nützlich: zum Aggregieren von Daten, bevor sie an die Datenquelle gesendet werden, und zum Zwischenspeichern von Informationen, um häufige Abfragen zu vermeiden. Da Sammlungen der tabellarischen Struktur der Datenquelle Power Apps entsprechen, können Sie mit ihnen effizient mit Daten interagieren, auch wenn Sie offline sind.

// Clear the contents of EmployeeCollection, it already contains data
ClearCollect(
    colEmployee,
    {
        Id: "1",
        Name: "John",
        Department: "IT"
    },
    {
        Id: "2",
        Name: "Nestor",
        Department: "IT"
    }
)

Entfernen Sie nicht verwendete Variablen und Medien

Während nicht verwendete Medien und Variablen die App-Leistung möglicherweise nicht erheblich beeinträchtigen, ist es wichtig, Ihre App zu bereinigen, indem Sie nicht verwendete Medien oder Variablen entfernen.

• Ungenutzte Mediendateien erhöhen die App-Größe, was die Ladezeiten der App verlangsamen kann.

• Nicht verwendete Variablen erhöhen die Speicherauslastung und können die App-Initialisierung leicht verlangsamen. Für diese Variablen werden Ressourcen zugeordnet, auch wenn sie nicht verwendet werden. Zu viele ungenutzte Variablen können auch die Logik der App komplexer machen.

• Verwenden Sie den App Checker, um nicht verwendete Medien und Variablen zu überprüfen.

Bildschirme und Steuerelemente optimieren

Um Bildschirme und Steuerelemente in Power Apps zu optimieren, sollten Sie die folgenden bewährten Methoden berücksichtigen.

Vermeiden Sie Querverweise auf Steuerelemente

Steuerelemente, die auf Steuerelemente auf anderen Bildschirmen verweisen, können das Laden und die Navigation in der App verlangsamen. Diese Vorgehensweise kann erzwingen, dass die App die anderen Bildschirme lädt, anstatt zu warten, bis der Benutzer zu diesem Bildschirm wechselt. Um dieses Problem zu beheben, verwenden Sie Variablen, Sammlungen und Navigationskontext, um den Zustand über Bildschirme hinweg freizugeben.

Der App-Checker in Power Apps Studio zeigt Steuerelemente an, die durch Querverweise referenziert werden. Überprüfen Sie den App-Checker regelmäßig, um das Problem zu beheben.

In der folgenden Abbildung wird die Galerie 1 im Steuerelement "Bildschirm 2" unter "Beschriftung 2" referenziert.

Wenn Sie auf ein Steuerelement vom ersten Bildschirm der App im zweiten Bildschirm verweisen, gibt es keine Leistungsbeeinträchtigung, da der erste Bildschirm bereits geladen ist. Dieses Verhalten ist tatsächlich von Vorteil, da die App deklarativ ist, anstatt Variablen zu verwenden.

Wenn Sie auf Steuerelemente verweisen, die noch nicht geladen wurden, z. B. auf den ersten Bildschirm, der auf ein Steuerelement mit dem Namen Label 3 von Bildschirm 3 verweist, lädt die App diesen Bildschirm in den Arbeitsspeicher.

DelayOutput für Textsteuerelemente aktivieren

Die DelayOutput-Einstellung registriert bei Festlegung auf "true" die Benutzereingabe nach einer halben Sekunde Verzögerung. Diese Verzögerung ist nützlich, um teure Vorgänge zu verschieben, bis der Benutzer die Eingabe von Text abgeschlossen hat, z. B. filtern, wenn eingaben in anderen Formeln verwendet werden.

Betrachten Sie beispielsweise einen Katalog, dessen Elemente gefiltert werden, je nachdem, was der Benutzer im TextInput-Steuerelement eingibt:

• Wenn Sie DelayOutput auf "false" festlegen, was der Standardwert ist, filtert der Katalog, sobald text eingegeben wird. Wenn Sie über eine Galerie mit vielen Elementen verfügen, verlangsamt das erneute Laden der Galerie mit Änderungen die Leistung. Es ist besser zu warten. Dieses Verhalten ist praktisch, wenn Sie die TextInput Suchzeichenfolge oder die StartsWith Funktion verwenden.

• Wenn Sie DelayOutput auf "true" festlegen, gibt es eine kurze Verzögerung, bevor die Änderungen erkannt werden. Diese Verzögerung bietet Zeit, um die Eingabe abzuschließen. Die Verzögerung funktioniert gut mit der TextInput.OnChange eigenschaft. Wenn Aktionen an Änderungen gebunden sind, sollen sie erst ausgelöst werden, wenn Sie die Eingabe im Feld abgeschlossen haben.

Delegierung und serverseitige Verarbeitung

Durch die Verwendung von Delegierung und serverseitiger Verarbeitung kann Ihre App große Datasets effizient verarbeiten, indem Vorgänge in die Datenquelle ausgelagert werden.

Delegation

Delegierung in Power Apps bezieht sich auf die Fähigkeit der App, bestimmte Vorgänge in die zugrunde liegende Datenquelle zu entladen, anstatt die Vorgänge in Power Apps selbst zu verarbeiten. Mithilfe der Delegierung in Power Apps können Sie effizientere und skalierbare Anwendungen erstellen, die auch in Szenarien mit großen Datasets gut funktionieren. Beachten Sie delegierungsbeschränkungen für bestimmte Datenquellen und Vorgänge, und entwerfen Sie Ihre App entsprechend, um eine optimale Leistung zu erzielen.

Die Delegierung hat mehrere Vorteile, z. B. Abfrageoptimierung und Unterstützung für große Datasets. Wenn sich die Quelldaten häufig ändern, hilft die Delegation außerdem dabei, die Daten auf dem neuesten Stand zu halten.

Reduzieren Sie die API-Aufrufe an die Datenquelle

Manchmal kann es praktisch erscheinen, Sammlungen zu erstellen, indem Sie Verknüpfungen innerhalb Ihrer Canvas-App durchführen. Betrachten Sie das folgende Beispiel. Im Beispiel gibt es zwei Tabellen: Fahrer und Lkw. Der Code erstellt eine Sammlung von Fahrer- und Lkw-Details und ruft für jeden Lkw den Fahrer an, dem der Lkw gehört.

// Bad code
ClearCollect(vartruckdata, AddColumns('Truck Details',
    "CITY",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],City),
        "FIRSTNAME",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],'Driver First Name'),
    "LASTNAME",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],'Driver Last Name'),
        "STATE",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],State)));

Das Ausführen einer solchen Verknüpfung in der Canvas-App kann viele Aufrufe an die Datenquelle verursachen, was zu langsamen Ladezeiten führt.

Ein besserer Ansatz ist:

// Good code
Set(
    varTruckData,
    LookUp(
        Drivers,
        'Dummy ID' = ThisRecord.'Dummy ID',
        'Driver First Name'
    ) & LookUp(
        Drivers,
        'Dummy ID' = ThisRecord.'Dummy ID',
        'Driver Last Name'
        )
);

Set(
    varTruckData,
    With(
        {
            vDriver: LookUp(
                Drivers,
                'Dummy ID' = ThisRecord.'Dummy ID'
            )
        },
        vDriver.'Driver First Name' & vDriver.'Driver Last Name'
    )
)

Im Echtzeitszenario können Sie die Ladezeiten von fünf Minuten auf unter 10 Sekunden reduzieren, indem Sie die Daten an der Quelle korrigieren.

Serverseitiges Verarbeiten

Mit verschiedenen Datenquellen, z. B. SQL und Dataverse, können Sie die Datenverarbeitung (z. B. Filter und Suchvorgänge) an die Datenquelle delegieren. In SQL Server können Sie Ansichten erstellen, die durch eine Abfrage definiert werden. In Dataverse können Sie Low-Code-Plug-Ins erstellen, um Daten auf dem Server zu verarbeiten und nur die Endergebnisse an Ihre Canvas-App zurückzugeben.

Das Delegieren der Datenverarbeitung an den Server kann die Leistung verbessern, den clientseitigen Code reduzieren und die Wartung Ihrer App vereinfachen.

Weitere Informationen zu Plug-Ins in Dataverse.

Abfragedatenmuster optimieren

Optimieren, wie Ihre App Daten abfragt, kann die Ladezeiten erheblich reduzieren und die Gesamtreaktionsfähigkeit verbessern.

Die explizite Spaltenauswahl verwenden

Die Funktion Explizite Spaltenauswahl (ECS) ist standardmäßig für alle neuen Apps aktiviert. Wenn sie nicht für Ihre App aktiviert ist, aktivieren Sie sie. ECS reduziert automatisch die Anzahl der abgerufenen Spalten auf die in der App verwendeten Spalten. Wenn ECS nicht aktiviert ist, erhalten Sie möglicherweise mehr Daten als Sie benötigen, was sich auf die Leistung auswirken kann. Manchmal, wenn eine App Daten über Sammlungen abruft, kann die ursprüngliche Quelle einer Spalte verloren gehen. ECS entfernt Spalten, wenn nicht festgestellt werden kann, dass sie verwendet werden. Verwenden Sie den Power Fx-Ausdruck ShowColumns nach einem Sammlungsverweis oder in einem Steuerelement, um ECS zu erzwingen, eine fehlende Spalte beizubehalten.

Power Automate nicht zum Befüllen einer Sammlung verwenden

Eine gängige Vorgehensweise besteht darin, Power Automate zu verwenden, um Sammlungen abzurufen und in Power Apps zu befüllen. Dieser Ansatz ist zwar gültig, es gibt jedoch Situationen, in denen er möglicherweise nicht die effizienteste Wahl ist. Das Aufrufen von Power Automate führt zu einer Netzwerklatenz und einer Leistungseinbuße von 0,6 Sekunden beim Starten des Power Automate-Flows.

Eine übermäßige Nutzung von Power Automate Flows kann auch zu Ausführungsbeschränkungen und Drosselung führen. Bewerten Sie immer die Kompromisse zwischen Netzwerklatenz und Leistungskosten.

Beseitigen Sie das N+1-Problem

Das N+1-Problem ist ein häufiges Problem bei Datenbankabfragen. Anstatt alle erforderlichen Daten in einer einzigen Abfrage abzurufen, werden mehrere zusätzliche Abfragen durchgeführt, um verwandte Daten abzurufen. Dieses Problem kann zu Leistungsproblemen führen, da bei jeder zusätzlichen Abfrage mehr Aufwand entsteht.

Ein einfacher Aufruf wie dieser zum Laden einer Sammlung kann N+1-Aufrufe an die Datenquelle generieren:

ClearCollect(MyCollection, OrdersList,
    {
        LookUp(CustomersList,CustomerID = OrdersList[@CustomerID])
    }
)

Im Kontext von Canvas-Apps und Katalogen kann das N+1-Problem auftreten, wenn Sie mit Datenquellen und Katalogen arbeiten, die verwandte Datensätze anzeigen. Das Problem tritt normalerweise auf, wenn für jedes in der Galerie angezeigte Element mehrere Abfragen durchgeführt werden, was zu einem Leistungsengpass führt.

Verwenden Sie Ansichtsobjekte in SQL Server, um das N+1-Abfrageproblem zu vermeiden, oder ändern Sie die Benutzeroberfläche, um das Auslösen des N+1-Szenarios zu vermeiden.

Dataverse ruft automatisch die erforderlichen Daten der verknüpften Tabellen ab und Sie können die Spalten aus den verknüpften Tabellen auswählen.

ThisItem.Account.'Account Name'

Wenn RelatedDataSource die Größe klein ist (weniger als 500 Datensätze), speichern Sie sie in einer Sammlung zwischenspeichern und verwenden Sie die Sammlung, um das Abfrageszenario Lookup (N+1) zu unterstützen.

Beschränken der Paketgröße

Obwohl Power Apps das Laden von Apps optimiert, können Sie Schritte ausführen, um den Speicherbedarf Ihrer Apps zu verringern. Ein reduzierter Ressourcenbedarf ist besonders wichtig für Benutzer älterer Geräte oder Benutzer in Regionen mit höheren Latenzen oder reduzierter Bandbreite.

• Bewerten Sie die in Ihre App eingebetteten Medien. Wenn etwas nicht verwendet wird, löschen Sie es.

  Eingebettete Bilder können z. B. zu groß sein. Prüfen Sie, ob Sie anstelle von PNG-Dateien SVG-Bilder verwenden können. Achten Sie darauf, Text in SVG-Bildern zu verwenden, da die Schriftart auf dem Client installiert sein muss. Eine Problemumgehung, wenn Sie Text anzeigen müssen, besteht darin, eine Textbeschriftung über ein Bild zu überlagern.

• Bewerten Sie, ob die Auflösung für den Formfaktor geeignet ist. Die Auflösung einer mobilen App muss nicht so hoch sein wie die Auflösung einer Desktop-App. Experimentieren Sie, um das richtige Gleichgewicht zwischen Bildqualität und -größe zu finden.

• Wenn Sie ungenutzte Bildschirme haben, löschen Sie diese. Achten Sie darauf, keine versteckten Bildschirme zu löschen, die nur von App-Entwicklern oder Administratoren verwendet werden.

• Überlegen Sie, ob Sie versuchen, zu viele Arbeitsabläufe in einer App unterzubringen. Haben Sie beispielsweise sowohl Administrator- als auch Client-Bildschirme in derselben App? Wenn ja, sollten Sie sie in einzelne Apps aufteilen. Dieser Ansatz erleichtert es auch mehreren Personen, gleichzeitig an den Apps zu arbeiten, und beschränkt den "Strahlradius" (Testmenge), wenn App-Änderungen einen vollständigen Testdurchlauf erfordern.

ForAll optimieren

Die ForAll-Funktion in Power Apps wird verwendet, um eine Datensatztabelle zu durchlaufen und auf jeden Datensatz eine Formel oder einen Satz von Formeln anzuwenden. Während die Funktion selbst vielseitig ist, kann die unsachgemäße Verwendung der ForAll Funktion ihre App schnell weniger leistungsfähig machen.

Die ForAll Funktion ist eine einzelne sequenzielle Funktion anstelle einer gleichzeitigen Funktion. Aus diesem Grund betrachtet es jeweils nur einen Datensatz, ruft das Ergebnis ab und fährt dann mit dem nächsten Datensatz fort, bis er alle Datensätze in seinem Bereich durchläuft.

Vermeiden Sie das Schachteln von Elementen ForAll. Diese Vorgehensweise kann zu exponentiellen Iterationen führen und die Leistung erheblich beeinträchtigen.

ClearCollect(FollowUpMeetingAttendees.ForAll(ForAll(Distinct(AttendeesList.EmailAddress.Address).Lookup(Attendees))))

Batchaktualisierung der Datenbank

Sie können ForAll und Patch verwenden, um die Datenbank batchweise zu aktualisieren. Seien Sie jedoch vorsichtig, wenn Sie die Reihenfolge von ForAll und Patch verwenden.

Die folgende Funktion ist beispielsweise der bessere Ansatz:

Patch(SampleFoodSalesData, ForAll(colSampleFoodSales,
    {
        demoName:"fromCanvas2"
    })
);

In der Erwägung, dass der folgende Ansatz weniger effizient ist:

ForAll(colSampleFoodSales, Patch(SampleFoodSalesData,
    {
        demoName:"test"
    })
);

Nächster Schritt