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.

Wanneer canvas-apps complexer worden, kunt u problemen ondervinden met het ophalen van gegevens, de complexiteit van formules en de weergavesnelheid. Om een goede balans te vinden tussen krachtige functionaliteit en een responsieve gebruikersinterface, hebt u een systematische aanpak voor code-optimalisatie nodig.

Optimalisatie 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. Het is beter om With te gebruiken dan contextvariabelen of globale variabelen, omdat deze functie op zichzelf staat en kan worden gebruikt in elke declaratieve formulecontext. Meer informatie over de With-functie.

De functie Concurrent

Met de functie Concurrent kunnen meerdere formules in dezelfde eigenschap tegelijkertijd worden geëvalueerd als deze aanroepen voor connectors of Dataverse 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 ;. Dankzij deze gelijktijdigheid hoeven gebruikers minder lang op de resultaten te wachten. 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 Concurrent-functie.

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

Coalesce-functie

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.

Bijvoorbeeld:

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

Vereist dat waarde 1 en waarde 2 tweemaal worden geëvalueerd. 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 IsMatch-functie.

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 eigenschap OnStart voor canvas-apps speelt een cruciale rol bij het definiëren van acties die plaatsvinden 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. Het begrijpen en effectief benutten van de OnStart-eigenschap is essentieel voor het maken van responsieve en efficiënte canvas-apps.

Een aanbevolen aanpak is om de App.OnStart functie te stroomlijnen door de instellingen van variabelen te migreren naar benoemde formules. Benoemde formules, vooral die welke vroeg in de app-levenscyclus zijn geconfigureerd, blijken voordelig te zijn. Deze formules verzorgen de initialisatie van variabelen op basis van dataoproepen, waardoor uw code een schonere en meer georganiseerde structuur krijgt. Meer details Bouw grote en complexe canvas-apps - Power Apps | Microsoft Learn.

Scherm starten

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

Als u de eigenschap StartScreen instelt, wordt het eerste scherm weergegeven voordat App.OnStart is voltooid. App.StartScreen declares welk schermobject als eerste moet worden weergegeven zonder enige voorbewerking.

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)

Raadpleeg <https://Power Apps.microsoft.com/en-us/blog/app-startscreen-a-new-declarative-alternative-to-navigate-in-app-onstart/> voor meer details.

Benoemde formules

Benoemde formules zijn statisch of constanten die kunnen worden gedefinieerd in de sectie App.Formulas. Eenmaal gedeclareerd in App.Formulas kunnen ze overal in de app worden gebruikt en blijft hun waarde altijd up-to-date. Benoemde formules in Power Apps maken de definitie van waarden of waardensets mogelijk die automatisch door het platform worden beheerd en bijgewerkt. Deze functionaliteit draagt ​​de verantwoordelijkheid voor waardeberekening en onderhoud over van de ontwikkelaar naar Power Apps, waardoor het ontwikkelingsproces wordt gestroomlijnd. Benoemde formules in Power Apps zijn een krachtige functionaliteit die de prestaties en onderhoudbaarheid van de app aanzienlijk kan verbeteren.

Benoemde formules kunnen ook betrekking hebben op het declareren van app-thema's. In veel gevallen waarin bedrijfsapps worden gebouwd, willen we dat de app gemeenschappelijke thema's heeft om een ​​consistent uiterlijk en gebruikerservaring te bieden. Om een thema te maken, zijn er tientallen en honderden variabelen die moeten worden gedeclareerd in App OnStart. Dit heeft de codelengte en initialisatietijd van de app verhoogd.

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.

De volgende code op App.OnStart kan bijvoorbeeld worden verplaatst naar App.Formulas, waardoor de opstarttijd voor declaraties van algemene variabelen wordt verkort.

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

De code kan als volgt naar App.Formulas worden verplaatst:

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 de instelling Lookups. Hier is een wijziging vereist in een opzoekformule om de gebruikersinformatie op te halen uit Office 365, in plaats van Dataverse. Er is maar één plaats waar de wijziging nodig is zonder dat de code overal hoeft te worden gewijzigd.

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 Set Functie moet de variabele varListItems worden geïnitialiseerd met het initiële aantal rijen in de voorbeeldlijst en opnieuw worden ingesteld nadat de lijstitems zijn toegevoegd of verwijderd. Met benoemde formules worden de varListitems-variabelen automatisch bijgewerkt als de gegevens veranderen.

Naamformules in de eigenschap App.Formulas bieden een flexibelere en declaratieve benadering voor het beheren van waarden en berekeningen in de hele app, en bieden voordelen op het gebied van onafhankelijkheid van timing, automatische updates, onderhoudbaarheid en onveranderlijke definities vergeleken met het uitsluitend vertrouwen op App.OnStart.

Door de gebruiker gedefinieerde functies

Met door de gebruiker gedefinieerde functies in Power Apps Authoring Studio kunnen gebruikers hun eigen aangepaste functies maken.

Om deze functie te gebruiken, schakelt u onder Voorbeeldinstellingen de optie Door gebruiker gedefinieerde functies (UDF's) in. De previewfunctionaliteit mag niet in productie worden gebruikt en is daarom standaard uitgeschakeld. Binnenkort wordt deze echter algemeen beschikbaar.

Definieer een formule onder App.Formulas als volgt:

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

De code werkt zo:

• FunctionName wordt gebruikt om de functie aan te roepen

• Parameter is de naam van de invoer. Een of meer invoeringangen zijn toegestaan

• DataType is een argument dat aan de functie wordt doorgegeven en moet overeenkomen met dit gegevenstype. Beschikbare gegevenstypen zijn onder meer Booleaans, Kleur, Datum, Datum/tijd, Dynamisch, GUID, Hyperlink, Tekst en Tijd

• OutputDataType is het gegevenstype waarin de uitvoer van de functie zich bevindt

• Formula is de uitvoer van de functie

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

Gebruik IfError om foutafhandeling binnen de gedefinieerde functie te implementeren.

Roep de gedefinieerde functie aan vanuit het tekst-/labelbesturingselement.

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. Hoewel de impact misschien niet groot is, is het toch verstandig om uw Power App overzichtelijk en georganiseerd te houden. Zo verbetert u de prestaties en verloopt de ontwikkeling eenvoudiger.

Optimaliseer collecties

Verzamelingen zijn tijdelijke gegevensopslagstructuren die u gebruikt om gegevens in een Power Apps-app op te slaan en te bewerken. Maar verzamelingen kunnen prestatieverlies veroorzaken als u ze te vaak gebruikt. 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 richtlijnen 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.

De volgende voorbeeldfunctie retourneert de volledige gegevensset.

ClearCollect(colDemoAccount, Accounts);

Vergelijk dit 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:

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 mogelijk geen significante invloed hebben op de app-prestaties, is het belangrijk om uw app op te schonen door ongebruikte media en 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

Kruisverwijzingen van besturingselementen vermijden

Bedieningselementen die verwijzen naar bedieningselementen op andere schermen kunnen het laden en navigeren van apps vertragen. Als u dit doet, kunt u de app dwingen om de andere schermen onmiddellijk te laden, in plaats van te wachten totdat de gebruiker naar dat specifieke scherm gaat. Om dit probleem op te lossen, gebruikt u in plaats hiervan variabelen, verzamelingen en navigatiecontext om de status met andere 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.

Hier is een voorbeeld van besturingselementen met kruisverwijzingen. In de onderstaande afbeelding is het besturingselement Galerie 1 een kruisverwijzing in het besturingselement Scherm 2, Label 2.

Als u in het tweede scherm in de app naar een besturingselement verwijst vanuit het eerste scherm, heeft dat geen gevolgen voor de prestaties, omdat het eerste scherm al is geladen. Dit kan eigenlijk wel positief zijn, omdat de app declaratief is en geen variabelen gebruikt.

Als u verwijst naar besturingselementen die nog niet zijn geladen, zoals wanneer het eerste scherm 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, als deze eigenschap is ingesteld op true, wordt gebruikersinvoer na een vertraging van een halve seconde geregistreerd. Dit is handig voor het uitstellen van tijdrovende bewerkingen totdat de gebruiker klaar is met het invoeren van tekst, zoals filteren als invoer wordt gebruikt in andere formules.

Bijvoorbeeld, voor een galerij waarvan de items worden gefilterd op basis van wat de gebruiker invoert in het besturingselement TextInput:

• Als u DelayOutput instelt op false (de standaardinstelling), wordt de galerij gefilterd zodra er tekst wordt getypt. Als u een galerij met veel items hebt, kan het direct opnieuw laden van de galerij met wijzigingen de prestaties vertragen. Het is beter om nog even te wachten. Dit is praktisch als u de TextInput gebruikt voor een zoekreeks (zie Zoeken of de nieuwe StartsWith-functies).

• Als DelayOutput is ingesteld op true, duurt het even voordat de wijzigingen worden gedetecteerd. Zo heeft u voldoende tijd om uw tekst af te typen. De vertraging werkt goed met de eigenschap TextInput.OnChange. Als u acties aan wijzigingen hebt gekoppeld, wilt u niet dat deze worden geactiveerd totdat u klaar bent met typen in het veld.

Delegatie en verwerking aan de serverzijde

Delegering

Delegatie in Power Apps is een concept dat verwijst naar het vermogen van de app om bepaalde bewerkingen over te dragen naar de onderliggende gegevensbron in plaats van de bewerkingen binnen Power Apps zelf te verwerken. Door gebruik te maken van delegatie in Power Apps kunnen ontwikkelaars efficiëntere en schaalbare applicaties maken die goed presteren, zelfs in scenario's met grote datasets. Het is belangrijk om op de hoogte te zijn van de delegatiebeperkingen voor specifieke gegevensbronnen en bewerkingen, en om apps dienovereenkomstig te ontwerpen om optimale prestaties te bereiken.

![LET OP] Niet alle functies zijn delegeerbaar. Raadpleeg Delegatie Begrijpen voor meer informatie over delegatie.

Delegatie heeft verschillende voordelen, zoals het toevoegen van ondersteuning voor grote gegevenssets en queryoptimalisatie. 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. Hier volgt een voorbeeld:

In dit voorbeeld zijn er twee tabellen: Chauffeurs en Vrachtwagens. 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 een realtimescenario kunt u de laadtijd terugbrengen van vijf minuten tot minder dan tien seconden door de gegevens bij de bron te corrigeren.

Verwerking aan de 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

Expliciete kolomselectie gebruiken

De functie Expliciete kolomselectie (ECS) is standaard ingeschakeld voor alle nieuwe apps. Als de functie niet is ingeschakeld voor uw app, schakel deze dan 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 niet kan worden vastgesteld dat ze in gebruik zijn. Als u ECS wilt dwingen een ontbrekende kolom te behouden, gebruikt u de PowerFx-expressie ShowColumns na een verzamelingsverwijzing 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. Het aanroepen Power Automate gaat gepaard met een overhead van netwerklatentie en voegt prestatiekosten van 0,6 seconde toe om de Power Automate-stroom te instantiëren.

Overmatig gebruik van Power Automate-stromen kan ook leiden tot uitvoeringslimieten en -beperkingen. Evalueer daarom altijd de afweging 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 kan leiden tot prestatieproblemen, omdat elke extra query overhead met zich meebrengt.

Een eenvoudige aanroep als deze om een verzameling te laden kan N+1-oproepen naar de gegevensbron genereren.

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

In de context van canvas-apps en galerijen kan het N+1-probleem optreden bij het werken met gegevensbronnen en galerijen 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 klein is (<500 records), kunt u deze in de cache opslaan in een verzameling en de verzameling gebruiken om het opzoekqueryscenario (N+1) aan te sturen.

Beperking van de pakketgrootte

Hoewel Power Apps er veel aan doet om het laden van apps te optimaliseren, kunt u stappen ondernemen om de voetafdruk van uw apps te verkleinen. Een kleinere voetafdruk is vooral belangrijk voor gebruikers van oudere apparaten, of gebruikers op locaties met een hogere latentie of verminderde bandbreedte.

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

• Ingesloten afbeeldingen zijn mogelijk te groot. Kijk of u in plaats van PNG-bestanden SVG-afbeeldingen kunt gebruiken. Wees echter voorzichtig met het gebruik van tekst in SVG-afbeeldingen, omdat het gebruikte lettertype op de client moet worden geïnstalleerd. Een goede oplossing als u tekst moet weergeven, is door een tekstlabel over een afbeelding heen te plaatsen.

• Evalueer of de oplossing geschikt is voor de formulierfactor. 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 gemakkelijker voor meerdere mensen om tegelijkertijd aan de apps te werken, en beperkt de "impactradius" (hoeveelheid testen) wanneer app-wijzigingen een volledige testdoorgang 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 oneigenlijk gebruik van de ForAll-functie ervoor zorgen dat uw app snel minder presteert.

De ForAll-functie is een enkelvoudige opeenvolgende functie in plaats van een gelijktijdige functie. Daarom kijkt het slechts naar één record tegelijk, krijgt het resultaat en gaat dan door naar het volgende totdat het alle records in zijn bereik heeft doorlopen.

Vermijd koste wat kost nesten van ForAll. Dit kan leiden tot exponentiële iteraties en een aanzienlijke impact hebben op de prestaties.

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

Batchgewijze updates voor database

ForAll + Patch kan een manier zijn om de database batchgewijs bij te werken. Wees echter voorzichtig met het gebruik van de volgorde voor ForAll en Patch.

De volgende functie:

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

Presteert beter dan:

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

Volgende stap