Share via

Codeoptimalisering

Omdat canvas-apps evolueren om te voldoen aan verschillende zakelijke behoeften, is het van cruciaal belang om de prestaties optimaal te houden. Gegevensverwerking, ontwerp van de gebruikersinterface en app-functionaliteit vereisen allemaal een zorgvuldige aanpak van code-optimalisatie.

Naarmate canvas-apps complexer worden, kunt u problemen ondervinden met het ophalen van gegevens, de complexiteit van de formule en de renderingsnelheid. Gebruik een systematische benadering voor het optimaliseren van code om een sterke functionaliteit te verdelen met een responsieve gebruikersinterface.

Optimalisatie van Power Fx-formules

Deze sectie bevat aanbevolen procedures voor het optimaliseren van Power Fx-formules.

De functie With

Met de functie With wordt een formule voor één record geëvalueerd. De formule kan een waarde berekenen of acties uitvoeren, zoals het wijzigen van gegevens of het werken met een verbinding. Gebruik With om complexe formules leesbaarder te maken door deze op te delen in kleinere, benoemde subformules. Deze benoemde waarden functioneren als eenvoudige lokale variabelen die beperkt zijn tot het bereik van With. With is beter dan context- of globale variabelen, omdat deze zelfstandig, gemakkelijk te begrijpen is en werkt in elke declaratieve formulecontext. Meer informatie over de functie With.

Schermopname van een Power Fx-formule die gebruikmaakt van de functie With.

De functie Concurrent

Met Concurrent de functie kunnen meerdere formules in dezelfde eigenschap tegelijkertijd worden geëvalueerd als ze connector- of Dataverse-aanroepen hebben. Normaal gesproken worden meerdere formules tegelijk geëvalueerd wanneer u ze aan elkaar koppelt met de operator ; (puntkomma). Met Concurrent evalueert de app alle formules in een eigenschap tegelijkertijd, zelfs na het gebruik van de operator ;. Deze gelijktijdigheid betekent dat gebruikers minder tijd wachten op resultaten. Wanneer gegevensaanroepen pas beginnen als de eerdere aanroepen zijn voltooid, wacht de app op de som van alle aanvraagtijden. Als gegevensaanroepen tegelijkertijd beginnen, wacht de app alleen op de langste aanvraagtijd. Meer informatie over de functie Concurrent.

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

Samenvoegingsfunctie

Met de functie Coalesce worden de bijbehorende argumenten op volgorde geëvalueerd en wordt de eerste waarde die niet leeg is of een lege tekenreeks geretourneerd. Gebruik deze functie om een lege waarde of lege tekenreeks te vervangen door een andere waarde, maar laat niet-lege waarden en tekenreeksen ongewijzigd. De functie retourneert leeg als alle argumenten leeg zijn of lege tekenreeksen. Coalesce is een goede manier om lege tekenreeksen naar lege waarden te converteren. Meer informatie over de functie Coalesce.

Dit voorbeeld vereist value1 en value2 moet tweemaal worden geëvalueerd:

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

Deze functie kan worden teruggebracht tot:

Coalesce(value1, value2)

IsMatch-functie

De functie IsMatch test of een teksttekenreeks overeenkomt met een patroon dat bestaat uit gewone tekens, vooraf gedefinieerde patronen of een reguliere expressie. Meer informatie over de functie IsMatch.

Deze formule komt bijvoorbeeld overeen met een sociaal-fiscaal nummer van de Verenigde Staten:

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

Uitleg van de reguliere expressie:

  • \\d Komt overeen met elk cijfer (0-9).

  • {3} Specificeert dat het voorgaande cijferpatroon (\d) precies drie keer moet voorkomen.

  • - Komt overeen met het koppelteken.

  • {2} Specificeert dat het voorgaande cijferpatroon (\d) precies twee keer moet voorkomen.

  • {4} Specificeert dat het voorgaande cijferpatroon (\d) precies vier keer moet voorkomen.

Meer voorbeelden van IsMatch:

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

App OnStart optimaliseren

De OnStart eigenschap voor canvas-apps speelt een cruciale rol bij het definiëren van acties die optreden wanneer de app wordt gestart. Met deze eigenschap kunnen app-ontwikkelaars globale initialisatietaken uitvoeren, variabelen instellen en acties uitvoeren die slechts één keer mogen plaatsvinden tijdens het opstartproces van de app. De eigenschap begrijpen en effectief gebruiken OnStart om responsieve en efficiënte canvas-apps te maken.

Stroomlijn de App.OnStart functie door het migreren van variabelen naar benoemde formules. Benoemde formules, met name formules die vroeg in de levenscyclus van de app zijn geconfigureerd, zijn voordelig. Deze formules verzorgen de initialisatie van variabelen op basis van dataoproepen, waardoor uw code een schonere en meer georganiseerde structuur krijgt. Meer informatie over het bouwen van grote en complexe canvas-apps.

Notitie

De OnStart eigenschap is imperatief. Het is een geordende lijst met werk dat moet worden uitgevoerd voordat het eerste scherm wordt weergegeven. Omdat het zo specifiek is over niet alleen wat er moet worden gedaan, maar ook wanneer dat werk moet worden uitgevoerd op basis van volgorde, beperkt het de volgorde en uitstel van optimalisaties die anders kunnen worden uitgevoerd.

Startscherm

Als App.OnStart een Navigate functieaanroep bevat, zelfs als deze zich in een If functie bevindt en zelden wordt aangeroepen, moet de app de uitvoering van App.OnStart voltooien voordat het eerste scherm van de app wordt weergegeven.  App.StartScreen is een declaratieve manier om aan te geven welk scherm als eerste moet worden weergegeven en optimalisaties worden niet geblokkeerd.

Als u de eigenschap StartScreen instelt, wordt het eerste scherm weergegeven voordat App.OnStart is voltooid. App.StartScreen declareert welk schermobject eerst moet worden weergegeven zonder dat er een voorverwerking nodig is.

In plaats van code te schrijven zoals:

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

Wijzig de code in:

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

Meer informatie: App.StartScreen: een declaratief alternatief voor Navigeren in App.OnStart.

Waarschuwing

Vermijd afhankelijkheden tussen StartScreen en OnStart. Als u verwijst naar een benoemde formule die op zijn beurt verwijst naar een globale variabele, kan dit leiden tot een racevoorwaarde waarin StartScreen niet correct wordt toegepast.

Maak geen afhankelijkheden tussen StartScreen en OnStart. Hoewel de app het refereren naar globale variabelen blokkeert in StartScreen, kunt u verwijzen naar een benoemde formule, die op zijn beurt naar een globale variabele verwijst. Deze aanpak kan een racevoorwaarde veroorzaken waarbij de StartScreen methode niet correct wordt toegepast.

Benoemde formules

Benoemde formules zijn statisch of constanten die kunnen worden gedefinieerd in App.Formulas. Eenmaal gedeclareerd App.Formulas, kunnen ze overal in de app worden gebruikt en blijven hun waarden altijd up-to-date. Met benoemde formules in Power Apps kunt u waarden of sets waarden definiëren die het platform automatisch beheert en bijwerkt. Deze functionaliteit verschuift de verantwoordelijkheid van waardeberekening en onderhoud van de ontwikkelaar naar Power Apps, waardoor het ontwikkelingsproces wordt stroomlijnd. Benoemde formules in Power Apps zijn een krachtige functie waarmee de prestaties en onderhoudbaarheid van apps aanzienlijk kunnen worden verbeterd.

Benoemde formules helpen ook bij het declareren van app-thema's. Wanneer u zakelijke apps bouwt, wilt u vaak dat de app algemene thema's heeft die een consistent uiterlijk en gebruikerservaring bieden. Als u een thema wilt maken, moet u tientallen tot honderden variabelen declareren in App.OnStart. Deze declaratie verhoogt de codelengte en de initialisatietijd van de app.

Moderne besturingselementen kunnen ook aanzienlijk helpen bij de vormgeving en helpen de door de klant geschreven logica voor vormgeving te verminderen. Moderne besturingselementen zijn momenteel beschikbaar als preview-versie.

U kunt bijvoorbeeld de volgende code App.OnStartApp.Formulasnaar verplaatsen, waardoor de opstarttijd voor globale variabeledeclaraties wordt verminderd.

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");

U kunt de code App.Formulas als volgt verplaatsen:

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";

Een ander voorbeeld is bij het instellen van Lookups. Hier is een wijziging vereist in een Lookup formule om de gebruikersgegevens op te halen uit Office 365 in plaats van Dataverse. U hoeft de wijziging slechts op één plaats aan te brengen, zonder de code overal te wijzigen.

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');

Deze formules vormen de essentie van de berekening. Ze beschrijven het proces voor het bepalen van UserEmail, UserInfo, UserTitle en UserPhone op basis van andere waarden. Deze logica is ingekapseld, waardoor wijdverbreid gebruik in de hele app mogelijk is, en kan op één locatie worden aangepast. Het aanpassingsvermogen strekt zich uit tot het overschakelen van de Dataverse-gebruikerstabel naar de Office 365-connector, zonder dat er wijzigingen nodig zijn in formules verspreid over de app.

Een andere aanpak is countRows te optimaliseren.

varListItems = CountRows(SampleList)

Met de Set functie moet u de variabele varListItems initialiseren met het eerste aantal rijen in de voorbeeldlijst en deze opnieuw instellen nadat de lijstitems zijn toegevoegd of verwijderd. Als de gegevens veranderen, wordt de varListItems variabele automatisch bijgewerkt met benoemde formules.

Benoemde formules in de App.Formulas eigenschap bieden een flexibelere en declaratieve benadering voor het beheren van waarden en berekeningen in de app. Ze bieden voordelen in termen van tijdsonafhankelijkheid, automatische updates, onderhoudbaarheid en onveranderbare definities vergeleken met uitsluitend App.OnStartafhankelijk zijn van .

Aspect Benoemde formules (App.Formulas) App.OnStart
Tijdsonafhankelijkheid Formules zijn direct beschikbaar en kunnen in elke volgorde worden berekend. Variabelen kunnen timingafhankelijkheden introduceren die van invloed zijn op de beschikbaarheid.
Automatische updates Formules worden automatisch bijgewerkt wanneer afhankelijkheden veranderen. Variabelen worden eenmaal ingesteld tijdens het opstarten; handmatige updates zijn mogelijk nodig.
Onderhoud Gecentraliseerde formules op één locatie verbeteren de onderhoudbaarheid. Voor verspreide variabelen moet u mogelijk op meerdere locaties zoeken en bijwerken.
Onveranderbare definities Formuledefinities zijn App.Formulas onveranderbaar. Variabele waarden kunnen vatbaar zijn voor onbedoelde wijzigingen.

Door de gebruiker gedefinieerde functies

Met door de gebruiker gedefinieerde functies in Power Apps Studio kunt u uw eigen aangepaste functies maken.

Definieer een formule onder App.Formulas als volgt:

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

De code werkt als volgt:

  • FunctionName roept de functie aan.

  • Parameter is de naam van de invoer. U kunt een of meer invoergegevens opnemen.

  • DataType is het gegevenstype dat het argument dat is doorgegeven aan de functie moet overeenkomen. Beschikbare gegevenstypen zijn booleaanse waarden, kleur, datum, datum/tijd, dynamisch, GUID, hyperlink, tekst en tijd.

  • OutputDataType is het gegevenstype voor de uitvoer van de functie.

  • Formula is de uitvoer van de functie.

Gebruik IfError dit om foutafhandeling binnen de gedefinieerde functie te implementeren:

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

Roep de gedefinieerde functie aan vanuit een tekst- of labelcontrole.

calcAreaOfCircle(Int(*TextInput1*.Text))

Optimaliseer variabelen

Variabelen definiëren en stellen lokale en globale waarden in die u in uw app gebruikt. Hoewel ze handig zijn, kan het gebruik van te veel variabelen uw app minder efficiënt maken.

Het volgende voorbeeld laat zien hoe u een variabele instelt voor elk kenmerk van een object. Hiervoor moet u Set voor elke eigenschap gebruiken.

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);

Een efficiëntere aanpak is om de eigenschap alleen te gebruiken wanneer u deze nodig hebt:

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

Gebruik contextvariabelen en globale variabelen verstandig. Als de reikwijdte van een variabele groter is dan één scherm, gebruik dan globale variabelen in plaats van contextvariabelen.

Te veel ongebruikte variabelen verhogen het geheugengebruik en kunnen de app-initialisatie vertragen. Er worden bronnen toegewezen aan deze variabelen, zelfs als u ze niet gebruikt. Ongebruikte variabelen voegen complexiteit toe aan de logica van uw app. Houd uw Power App schoon en georganiseerd voor betere prestaties en eenvoudigere ontwikkeling.

Optimaliseer collecties

Verzamelingen zijn tijdelijke gegevensopslagstructuren die u gebruikt om gegevens in een Power Apps-app op te slaan en te bewerken. Verzamelingen kunnen echter prestatieoverhead veroorzaken. Beperk het gebruik van verzamelingen en gebruik ze alleen als het nodig is.

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

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

Om records in een lokale verzameling te tellen, gebruikt u CountIf in plaats van Count(Filter()).

Houd rekening met deze aanpak bij het werken met verzamelingen:

  • Beperk de omvang en het aantal collecties. Omdat verzamelingen lokaal in de app zijn opgeslagen, worden ze opgeslagen in het geheugen van het mobiele apparaat. Hoe meer gegevensverzamelingen u hebt of hoe meer verzamelingen u gebruikt, hoe slechter de prestaties. Gebruik de functie ShowColumns om alleen specifieke kolommen op te halen. Voeg de functie Filter toe om alleen relevante gegevens op te halen.

    Met de volgende voorbeeldfunctie wordt de hele gegevensset geretourneerd:

    ClearCollect(colDemoAccount, Accounts);

    Vergelijk deze functie met de volgende code, die alleen specifieke records en kolommen retourneert:

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

    In dit voorbeeld wordt de volgende dataset geretourneerd:

    Schermopname van een gegevensset met een tabel met de naam colAcc en twee kolommen, address1_city en naam.

  • Stel een vernieuwingsfrequentie voor de gegevensbron in. Als u nieuwe records toevoegt aan de verzameling, vernieuw deze dan of verzamel ernaar om de nieuwe of gewijzigde records op te halen. Als meerdere gebruikers uw gegevensbron bijwerken, vernieuw dan de verzameling om de nieuwe of gewijzigde records op te halen. Meer vernieuwingsaanroepen betekenen meer interactie met de server.

Gegevens cachen in verzamelingen en variabelen

Een verzameling is een tabelvariabele waarin rijen en kolommen met gegevens worden opgeslagen, en niet slechts één enkel gegevensitem. Verzamelingen zijn om twee belangrijke redenen nuttig: het samenvoegen van gegevens voordat deze naar de gegevensbron worden verzonden en het cachen van informatie om frequente query's te voorkomen. Omdat verzamelingen overeenkomen met de tabelstructuur van de gegevensbron en Power Apps, zorgen ze ervoor dat u efficiënt met gegevens kunt werken, zelfs als u offline bent.

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

Verwijder ongebruikte variabelen en media

Hoewel ongebruikte media en variabelen de prestaties van apps mogelijk niet aanzienlijk beïnvloeden, is het belangrijk om uw app op te schonen door ongebruikte media of variabelen te verwijderen.

  • Ongebruikte mediabestanden vergroten de app-grootte, wat de laadtijd van de app kan vertragen.

  • Ongebruikte variabelen verhogen het geheugengebruik en kunnen de app-initialisatie enigszins vertragen. Er worden bronnen toegewezen aan deze variabelen, ook als ze niet worden gebruikt. Als er te veel variabelen ongebruikt zijn, kan de logica van de app complexer worden.

  • Gebruik App Checker om ongebruikte media en variabelen te beoordelen.

Optimaliseer schermen en bedieningselementen

Houd rekening met de volgende aanbevolen procedures om schermen en besturingselementen in Power Apps te optimaliseren.

Kruisverwijzingen van besturingselementen vermijden

Bedieningselementen die verwijzen naar bedieningselementen op andere schermen kunnen het laden en navigeren van apps vertragen. Met deze methode kan de app de andere schermen laden in plaats van te wachten totdat de gebruiker naar dat scherm gaat. U kunt dit probleem oplossen door variabelen, verzamelingen en navigatiecontext te gebruiken om de status over schermen te delen.

De app-controle in Power Apps Studio toont besturingselementen waarnaar kruisverwijzingen bestaan. Controleer App Checker regelmatig om dit probleem op te lossen.

In de volgende afbeelding is het besturingselement Galerie 1 kruislings verwezen in het besturingselement Scherm 2, Label 2.

Schermopname van Power Apps Studio met een gekruiste verwijzingscontrole.

Als u in het tweede scherm van de app verwijst naar een controle van het eerste scherm, is er geen sprake van performanceverlies omdat het eerste scherm al is geladen. Dit gedrag is eigenlijk nuttig omdat de app declaratief is in plaats van variabelen te gebruiken.

Als u verwijst naar besturingselementen die nog niet zijn geladen, zoals het eerste scherm dat verwijst naar een besturingselement met de naam Label 3 van scherm 3, laadt de app dat scherm in het geheugen.

DelayOutput inschakelen voor tekstbesturingselementen

De instelling DelayOutput , indien ingesteld op true, registreert gebruikersinvoer na een vertraging van een halve seconde. Deze vertraging is handig voor het uitstellen van dure bewerkingen totdat de gebruiker klaar is met het invoeren van tekst, zoals filteren wanneer invoer wordt gebruikt in andere formules.

Denk bijvoorbeeld aan een galerie waarvan items worden gefilterd, afhankelijk van wat de gebruiker invoert in het besturingselement TextInput:

  • Als u DelayOutput instelt op false, wat de standaardinstelling is, wordt de galerie gefilterd zodra er tekst wordt getypt. Als u een galerie met veel items hebt, vertraagt u de prestaties als u de galerie opnieuw laadt met wijzigingen. Het is beter om te wachten. Dit gedrag is praktisch wanneer u de TextInput functie voor een zoektekenreeks of de StartsWith functie gebruikt.

  • Als u DelayOutput instelt op true, is er een korte vertraging voordat de wijzigingen worden gedetecteerd. Deze vertraging biedt tijd om het typen te voltooien. De vertraging werkt goed met de TextInput.OnChange eigenschap. Als er acties zijn gekoppeld aan wijzigingen, wilt u ze pas activeren als u klaar bent met typen in het veld.

Delegering en verwerking aan de serverzijde

Door delegering en verwerking aan de serverzijde te gebruiken, kan uw app grote gegevenssets efficiënt verwerken door bewerkingen naar de gegevensbron te offloaden.

Delegatie

Delegering in Power Apps verwijst naar de mogelijkheid van de app om bepaalde bewerkingen te offloaden naar de onderliggende gegevensbron in plaats van de bewerkingen in Power Apps zelf te verwerken. Met behulp van delegatie in Power Apps kunt u efficiëntere en schaalbare toepassingen maken die goed presteren, zelfs in scenario's met betrekking tot grote gegevenssets. Houd rekening met delegeringsbeperkingen voor specifieke gegevensbronnen en bewerkingen en ontwerp uw app dienovereenkomstig om optimale prestaties te bereiken.

Notitie

Niet alle functies zijn delegeerbaar. Meer informatie over delegering in Querybeperkingen: Delegering en querylimieten.

Delegatie heeft verschillende voordelen, zoals queryoptimalisatie en ondersteuning voor grote gegevenssets. Als de brongegevens regelmatig veranderen, helpt delegatie bovendien om de gegevens up-to-date te houden.

Verminder API-aanroepen naar de gegevensbron

Soms kan het handig lijken om verzamelingen te creëren door joins uit te voeren in uw canvas-app. Bekijk het volgende voorbeeld. In het voorbeeld zijn er twee tabellen: Drivers en Trucks. De code maakt een verzameling van chauffeurs en vrachtwagendetails en contacteert voor elke vrachtwagen de chauffeur die eigenaar is van de vrachtwagen.

// 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)));

Het uitvoeren van een dergelijke join in de canvas-app kan veel aanroepen naar de gegevensbron genereren, wat leidt tot lange laadtijden.

Een betere aanpak is:

// 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'
    )
)

In het realtime-scenario kunt u laadtijden verminderen van vijf minuten tot minder dan 10 seconden door de gegevens op de bron te herstellen.

Verwerking aan serverzijde

Met verschillende gegevensbronnen, zoals SQL en Dataverse, kunt u gegevensverwerking, zoals filters en zoekopdrachten, aan de gegevensbron delegeren. In SQL Server kunt u weergaven maken die zijn gedefinieerd door een query. In Dataverse kunt u invoegtoepassingen met weinig code maken om gegevens op de server te verwerken en alleen de uiteindelijke resultaten naar uw canvas-app te retourneren.

Door gegevensverwerking te delegeren aan de server, kunt u de prestaties verbeteren, de hoeveelheid code aan de clientzijde verminderen en uw app eenvoudiger onderhouden.

Meer informatie over invoegtoepassingen in Dataverse.

Querygegevenspatronen optimaliseren

Door te optimaliseren hoe uw app query's uitvoert op gegevens, kunnen laadtijden aanzienlijk worden verminderd en de algehele reactiesnelheid worden verbeterd.

Expliciete kolomselectie gebruiken

De functie Expliciete kolomselectie (ECS) is standaard ingeschakeld voor alle nieuwe apps. Als deze niet is ingeschakeld voor uw app, schakelt u deze in. ECS beperkt automatisch het aantal opgehaalde kolommen tot alleen de kolommen die in de app worden gebruikt. Als ECS niet is ingeschakeld, ontvangt u mogelijk meer gegevens dan nodig is, wat van invloed kan zijn op de prestaties. Soms kan de oorspronkelijke bron van een kolom verloren gaan wanneer een app gegevens via verzamelingen ontvangt. ECS verwijdert kolommen als het niet kan vaststellen dat ze worden gebruikt. Als u wilt afdwingen dat ECS een ontbrekende kolom behoudt, gebruikt u de Power Fx-expressie ShowColumns na een verzamelingsreferentie of in een besturingselement.

Het aanroepen van Power Automate vermijden om een verzameling te vullen

Een veel voorkomende praktijk is om Power Automate te gebruiken om verzamelingen op te halen en in te vullen in Power Apps. Hoewel deze aanpak geldig is, zijn er situaties waarin dit misschien niet de meest efficiënte keuze is. Als u Power Automate aanroept, worden netwerklatentie en prestatiekosten van 0,6 seconden toegevoegd voor het instantiëren van de Power Automate-flow.

Overmatig gebruik van Power Automate-flows kan ook leiden tot uitvoeringslimieten en throttling. Evalueer altijd de afwegingen tussen netwerklatentie en prestatiekosten.

Elimineer het N+1-probleem

Het N+1-probleem is een veelvoorkomend probleem bij databasequery's waarbij, in plaats van alle vereiste gegevens in één enkele query op te halen, meerdere extra query's worden uitgevoerd om gerelateerde gegevens op te halen. Dit probleem kan leiden tot prestatieproblemen, omdat elke extra query overhead veroorzaakt.

Een eenvoudige aanroep zoals deze voor het laden van een verzameling kan N+1-aanroepen naar de gegevensbron genereren:

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

In de context van canvas-apps en galerieën kan het probleem N+1 optreden bij het werken met gegevensbronnen en galerieën die gerelateerde records weergeven. Het probleem treedt meestal op wanneer er meer zoekopdrachten worden uitgevoerd voor elk item dat in de galerij wordt weergegeven, wat tot een prestatieknelpunt leidt.

Gebruik View-objecten in SQL Server om N+1-queryproblemen te voorkomen, of wijzig de gebruikersinterface om te voorkomen dat het N+1-scenario wordt geactiveerd.

Dataverse haalt automatisch de vereiste gegevens van gerelateerde tabellen op en u kunt de kolommen uit gerelateerde tabellen selecteren.

ThisItem.Account.'Account Name'

Als RelatedDataSource de grootte klein is (minder dan 500 records), slaat u deze in een verzameling op en gebruikt u de verzameling om het opzoekqueryscenario (N+1) aan te sturen.

De pakketgrootte beperken

Hoewel Power Apps het laden van apps optimaliseert, kunt u stappen ondernemen om de footprint van uw apps te verminderen. Een kleinere voetafdruk is vooral belangrijk voor gebruikers van oudere apparaten of gebruikers in gebieden met een hogere latentie of lagere bandbreedte.

  • Evalueer de media die zijn ingesloten in uw app. Als iets niet wordt gebruikt, verwijder het dan.

    Ingesloten afbeeldingen kunnen bijvoorbeeld te groot zijn. Kijk of u in plaats van PNG-bestanden SVG-afbeeldingen kunt gebruiken. Wees voorzichtig met het gebruik van tekst in SVG-afbeeldingen omdat het lettertype op de client moet worden geïnstalleerd. Een tijdelijke oplossing wanneer u tekst wilt weergeven, is door een tekstlabel boven een afbeelding te plaatsen.

  • Evalueer of de resolutie geschikt is voor de form factor. De resolutie voor een mobiele app hoeft niet zo hoog te zijn als de resolutie voor een desktop-app. Experimenteer om de juiste balans tussen beeldkwaliteit en -grootte te vinden.

  • Als u ongebruikte schermen hebt, verwijder dan deze. Zorg ervoor dat u geen verborgen schermen verwijdert die alleen app-makers of beheerders gebruiken.

  • Evalueer of u te veel workflows in één app probeert te passen. Hebt u bijvoorbeeld zowel beheerdersschermen als klantschermen in dezelfde app? Als dat zo is, overweeg dan om ze op te splitsen in afzonderlijke apps. Deze aanpak maakt het ook eenvoudiger voor meerdere personen om tegelijkertijd aan de apps te werken en het beperkt de 'effectradius' (testvolume) wanneer app-wijzigingen een volledige testcyclus vereisen.

ForAll optimaliseren

De ForAll functie in Power Apps wordt gebruikt om een ​​tabel met records te doorlopen en een formule of een reeks formules op elke record toe te passen. Hoewel de functie zelf veelzijdig is, kan een onjuist gebruik van de ForAll functie uw app snel minder goed laten presteren.

De ForAll functie is een enkelvoudige sequentiële functie in plaats van een gelijktijdige functie. Daarom bekijkt het slechts één gegevensset tegelijk, haalt het resultaat op en gaat dan naar het volgende record over totdat alle records in het volledige bereik zijn doorlopen.

Vermijd nesten ForAll. Deze praktijk kan leiden tot exponentiële iteraties en de prestaties aanzienlijk beïnvloeden.

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

De database bijwerken in Batch

U kunt ForAll en Patch gebruiken om de database batchgewijs bij te werken. Wees echter voorzichtig wanneer u de volgorde van ForAll en Patch.

De volgende functie is de betere benadering, bijvoorbeeld:

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

Overwegende dat de volgende aanpak minder efficiënt is:

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

Volgende stap

Foutafhandeling

  • Last updated on