Kodeoptimering

Efterhånden som lærredapps udvikler sig for at imødekomme forskellige forretningsbehov, er det vigtigt at holde ydeevnen optimal. Datahåndtering, brugergrænsefladedesign og appfunktionalitet kræver alle en omhyggelig tilgang til kodeoptimering.

Når lærredapps bliver mere komplekse, kan du løbe ind i problemer med datahentning, formelkompleksitet og gengivelseshastighed. Balancering af stærk funktionalitet og en responsiv brugergrænseflade betyder, at du har brug for en systematisk tilgang til kodeoptimering.

Power Fx optimering af formler

Funktionen With

Funktionen With evaluerer en formel for en enkelt post. Formlen kan beregne en værdi/udføre handlinger, f.eks. ændre data eller arbejde med en forbindelse. Brug With til at forbedre læsbarheden af komplekse formler ved at dele dem i mindre navngivne underformler. Disse navngivne værdier fungerer på samme måde som simple lokale variabler, der er begrænset til omfanget af With. Brug af With er bedre end kontekstafhængige eller globale variabler, da den er komplet, let at forstå og kan bruges i alle deklarative formelkontekster. Få mere at vide om With-funktionen.

Funktionen Concurrent

Med funktionen Concurrent kan flere formler, der er angivet i samme egenskab, evalueres samtidigt, hvis de har en connector eller et Dataverse-kald. Normalt evalueres flere formler samtidigt, når du kæder dem sammen med operatoren ; (semikolon). Med Concurrent evaluerer appen alle formler i en egenskab på samme tid, selv efter brug af operatoren ;. Denne samtidighed betyder, at brugerne venter mindre på resultater. Når datakald ikke starter, før det forrige kald er færdigt, skal appen vente på summen af alle anmodningstider. Hvis datakald starter på samme tid, skal appen kun vente på den længste anmodningstid. Få mere at vide om Concurrent-funktionen.

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

Coalesce Funktion

Funktionen Coalesce evaluerer argumenterne i rækkefølge og returnerer den første værdi, der ikke er tom eller en tom streng. Brug denne funktion til at erstatte en værdi af typen blank eller en tom streng med en anden værdi, men bevare strengværdier, som ikke er af typen blank, og som ikke er tomme. Hvis alle argumenterne er tomme eller tome strenge, returnerer funktionen tom. Coalesce er en god metode til at konvertere tomme strenge til tomme værdier.

Eksempel:

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

Kræver værdi 1 og værdi 2, der skal evalueres to gange. Denne funktion kan reduceres til:

Coalesce(value1, value2)

IsMatch-funktion

Funktionen IsMatch tester, om en tekststreng matcher et mønster, der kan bestå af almindelige tegn, foruddefinerede mønstre eller et regulært udtryk. Få mere at vide om IsMatch-funktionen.

F.eks. matcher denne formular et United States Social Security Number:

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

Forklaring af det regulære udtryk:

\\d Matcher ethvert ciffer (0-9).

{3} Angiver, at det foregående cifrede mønster (\d) skal forekomme nøjagtigt tre gange.

- Matcher bindestregstegnet.

{2} Angiver, at det foregående cifrede mønster (\d) skal forekomme nøjagtigt to gange.

{4} Angiver, at det foregående cifrede mønster (\d) skal forekomme nøjagtigt fire gange.

Flere eksempler på IsMatch:

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

Optimer OnStart i appen

Egenskaben OnStart for lærredsapps spiller en vigtig rolle ved definition af handlinger, der indtræffer, når appen startes. Denne egenskab gør det muligt for appudviklere at udføre opgaver i forbindelse med global initialisering, konfigurere variabler og udføre handlinger, der kun skal udføres én gang i løbet af startprocessen for appen. Forståelse og effektiv udnyttelse af OnStart egenskab er afgørende for at skabe responsive og effektive lærredapps.

Det anbefales at strømline funktionen App.OnStart ved at overføre variabelopsætninger til navngivne formler. Navngivne formler, især dem, der er konfigureret tidligt i appens livscyklus, viser sig at være nyttige. Disse formler håndterer initialisering af variabler baseret på dataopkald, hvilket giver en renere og mere organiseret struktur for koden. Flere detaljer Opbygning af store og komplekse lærredsapps - Power Apps | Microsoft Learn.

Bemærk

Egenskaben OnStart er vigtig. Det er en ordnet liste over arbejde, der skal udføres, før det første skærmbillede vises. Da det ikke kun handler om, hvad der skal gøres, men også om, hvornår arbejdet skal udføres på ordre, begrænser det den omarrangering og udskydelse af optimeringer, der ellers kunne udføres.

Start skærmbillede

Hvis App.OnStart indeholder et Navigate-funktionsopkald, selv om det er en If-funktion, og som sjældent kaldes, skal vi fuldføre eksekvering af appen, selvom det er i en funktion og sjældent kaldes. OnStart før vi viser det første skærmbillede i appen.  App.StartScreen er den nye beskrivende måde at angive, hvilket skærmbillede der skal vises først, hvilket ikke blokerer optimeringer.

Indstilling af StartScreen egenskaben viser det første skærmbillede, før App.OnStart er fuldført. App.StartScreen declares hvilket skærmobjekt der skal vises først, uden at det er nødvendigt at forbehandle det.

I stedet for at skrive kode som:

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

Ændre koden for at:

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

Se <https://Power Apps.microsoft.com/en-us/blog/app-startscreen-a-new-declarative-alternative-to-navigate-in-app-onstart/> for at få flere oplysninger.

Advarsel!

Undgå afhængigheder mellem StartScreen og OnStart. Hvis du refererer til en navngivet formel, der igen refererer til en global variabel, kan det medføre en racebetingelse, som StartScreen ikke anvendes korrekt. Bemærk: Vi bør ikke have afhængigheder mellem StartScreen og OnStart. Vi blokerer referencer til globale variabler i StartScreen, men vi kan referere til en navngivet formel, der igen refererer til en global variabel, og som kan forårsage en racetilstand, hvor StartScreen ikke anvendes korrekt.

Navngivne formler

Navngivne formler er statiske eller konstanter, der kan defineres i sektionen App.Formulas. Når de er erklæret i App.Formulas, kan de bruges alle steder i appen, og deres værdi er altid opdateret. Navngivne formler i Power Apps muliggør definitionen af værdier eller sæt af værdier, der automatisk administreres og opdateres af platformen. I denne funktion overføres ansvaret for værdiberegning og vedligeholdelse fra udvikleren til Power Apps, hvilket forenkler udviklingsprocessen. Navngivne formler i Power Apps er en effektiv funktionalitet, der kan forbedre appens ydeevne og vedligeholdelighed betydeligt.

Navngivne formler kan også håndtere apptemaer. I mange tilfælde, hvor der oprettes virksomhedsapps, ønsker vi, at appen har fælles temaer, så udseendet og brugeroplevelsen bliver ensartet. Hvis du vil oprette et tema, er der 10'ere og 100'ere variabler, der skal deklareres i App OnStart. Dette forøgede kodelængden og initialiseringstiden for appen.

Moderne kontrolelementer kan også hjælpe betydeligt med tematisering og hjælpe med at reducere kundeskrevet logik til håndtering af tematisering. Moderne kontrolelementer er i øjeblikket som forhåndsversion.

For eksempel kan den følgende kode på App.OnStart flyttes til App.Formulas, hvilket reducerer opstartstiden for erklæringer af globale variabler.

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

Koden kan flyttes til App.Formulas på følgende måde:

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

Et andet eksempel er inn-indstilling Lookups. Her kræves der en ændring i en opslagsformel for at få brugeroplysningerne fra Office 365 i stedet for Dataverse. Ændringen er kun nødvendig på ét sted, uden at koden ændres alle steder.

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

Disse formler repræsenterer kernen i beregningen. De formulerer processen for at bestemme UserEmail, UserInfo, UserTitle og UserPhone baseret på andre værdier. Denne logik er indkapslet, hvilket gør det muligt at udnytte den i hele appen, og kan ændres på et enkelt sted. Tilpasningen omfatter skift fra Dataverse brugertabellen til Office 365-connectoren uden at nødvendiggøre ændringer i formler spredt over hele appen.

En anden fremgangsmåde er at optimere countRows.

varListItems = CountRows(SampleList)

Med Set Funktion skal variablen varListItems initialiseres med det første antal rækker på eksempellisten og angives igen, efter at listeelementerne er tilføjet eller fjernet. Med navngivne formler, opdateres variablerne af varListitems automatisk, når dataene ændres.

Navngivne formler i App.Formulas egenskaben giver en mere fleksibel og beskrivende fremgangsmåde til administration af værdier og beregninger i hele appen, hvilket giver fordele med hensyn til timing, automatiske opdateringer, vedligeholdelsesmuligheder og uforanderlige definitioner i forhold til kun at være afhængig af App.OnStart.

Aspekt	Navngivne formler (App.Formulas)	App.OnStart
Timing Uafhængighed	Formler er tilgængelige med det samme og kan beregnes i en hvilken som helst rækkefølge.	Variabler kan introducere afhængigheder af timing, hvilket påvirker tilgængeligheden.
Automatiske opdateringer	Formler opdateres automatisk, når afhængigheder ændres.	Variabler angives én gang under start. Manuelle opdateringer kan være nødvendige.
Mulighed for vedligeholdelse	Centrale formler på ét sted forbedrer vedligeholdelsesmulighederne.	Variabler, der er spredt, kan kræve søgning og opdatering på flere steder.
Uforanderlige definitioner	Formeldefinitioner i App.Formulas er uforanderlige.	Variable værdier kan være sårbare over for utilsigtede ændringer.

Brugerdefinerede funktioner

Brugerdefinerede funktioner i Power Apps Authoring Studio giver brugerne mulighed for at oprette deres egen brugerdefinerede funktion.

Hvis du vil bruge denne funktion, skal du aktivere brugerdefineret funktion (UDF'er) under indstillinger for forhåndsversion. Eksempelvisningsfunktionen bør ikke bruges i produktionen, hvilket er grunden til, at den er deaktiveret som standard, men den bliver snart generelt tilgængelig.

Definer en formel under App.Formulas som følger:

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

Koden fungerer på følgende måde:

• FunctionName bruges til at kalde funktionen

• Parameter er navnet på inputtet. En eller flere inputs er tilladt

• DataType er et argument, der overføres til funktionen, og det skal svare til denne datatype. Tilgængelige datatyper omfatter boolesk, farve, dato, datetime, dynamisk, GUID, hyperlink, tekst og klokkeslæt

• OutputDataType er den datatype, funktionens output vises i

• Formula er resultatet af funktionen

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

Brug IfError til at implementere fejlhåndtering inden for den definerede funktion.

Kald den definerede funktion fra tekst-/etiketkontrolelementet.

calcAreaOfCircle(Int(*TextInput1*.Text))

Bemærk

Det er en eksperimentel funktion og kan ændres. Visse datatyper, f.eks. poster og filtre, understøttes endnu ikke.

Optimer variabler

Variabler definerer og angiver lokale og globale værdier, du bruger i hele appen. Selvom de er praktiske, kan for mange variabler gøre din app mindre effektiv.

Følgende eksempel viser, hvordan du angiver en variabel for hver attribut i et objekt, som kræver brug af Set for hver egenskab.

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

En mere effektiv fremgangsmåde er kun at bruge egenskaben, når du har brug for den:

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

Brug kontekstvariabler og globale variabler klogt. Hvis en variabels omfang rækker ud over et enkelt skærmbillede, skal du bruge globale variabler i stedet for kontekstafhængige variabler.

For mange ubrugte variabler øger hukommelsesforbruget og kan gøre initialiseringen af apps langsommere. Der allokeres ressourcer til disse variabler, selvom du ikke bruger dem. Ubrugte variabler gør også appens logik mere kompleks. Selvom påvirkningen måske ikke er alvorlig, er det en god praksis at holde din Power App ren og organiseret for bedre ydeevne og lettere udvikling.

Optimer samlinger

Samlinger er midlertidige strukturer til datalagring, som du bruger til at gemme og manipulere data i en Power Apps app. Men samlinger kan forårsage ydeevneoverhead, hvis du bruger dem for meget. Begræns din brug af samlinger, og brug dem kun, når det er nødvendigt.

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

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

Hvis du vil tælle poster i en lokal samling, skal du bruge CountIf i stedet for Count(Filter()).

Overvej denne vejledning, når du arbejder med samlinger:

Begræns størrelsen på og antallet af samlinger. Da samlinger er lokale for appen, gemmes de i mobilenhedens hukommelse. Jo flere data samlingerne indeholder, eller jo flere samlinger du bruger, jo dårligere er ydeevnen. Brug ShowColumns funktionen til kun at hente bestemte kolonner. Tilføj Filter funktionen for kun at hente relevante data.

Følgende eksempelfunktion returnerer hele datasættet.

ClearCollect(colDemoAccount, Accounts);

Sammenlign dette med følgende kode, som kun returnerer bestemte poster og kolonner:

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

I dette eksempel returneres følgende datasæt:

Angiv en datakilde opdateringshyppighed. Hvis du føjer nye poster til samlingen, skal du opdatere den eller indsamle dem til den for at hente de nye eller ændrede poster. Hvis flere brugere opdaterer datakilden, skal du opdatere samlingen for at hente de nye eller ændrede poster. Flere opdateringsopkald betyder mere interaktion med serveren.

Cache data i samlinger og variabler

En samling er en tabelvariabel, der gemmer rækker og kolonner med data, ikke kun et enkelt dataelement. Samlinger er nyttige af to hovedårsager: aggregering af data, før de sendes til datakilden, og cachelagring af oplysninger for at undgå hyppige forespørgsler. Da samlinger matcher datakildens tabelstruktur og Power Apps, giver de dig mulighed for at interagere effektivt med data, selv når du er offline.

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

Fjern ubrugte variabler og medier

Selvom ubrugte medier og variabler muligvis ikke har nogen væsentlig indvirkning på appens ydeevne, er det vigtigt at rydde op i appen ved at fjerne alle ubrugte medier eller variabler.

• Ubrugte mediefiler øger appstørrelsen, hvilket kan bremse appens indlæsningstider.

• Ubrugte variabler øger hukommelsesforbruget og kan gøre initialiseringen af apps lidt langsommere. Der allokeres ressourcer til disse variabler, selvom de ikke bruges. For mange ubrugte variabler kan også gøre appens logik mere kompleks.

• Brug App Checker til at gennemse ubrugte medier og variabler.

Optimer skærmbilleder og kontrolelementer

Undgå at krydsreferere kontrolelementer

Kontrolelementer, der henviser til kontrolelementer på andre skærme, kan gøre indlæsning og navigation langsommere i apps. Hvis du gør dette, kan appen tvinges til at indlæse de andre skærmbilleder med det samme i stedet for at vente, indtil brugeren går til den pågældende skærm. Løs dette problem ved at bruge variabler, samlinger og navigationskontekster til at dele tilstand på tværs af skærmbilleder i stedet.

App-kontrollen i Power Apps Studio viser kontrolelementer, der er krydsrefereret. Gennemgå App-kontrollen regelmæssigt for at løse dette problem.

Her er et eksempel på kontrolelementer, der henvises til på tværs. På billedet nedenfor er der krydsreferencer til kontrolelementet Gallery 1 i kontrolelementet Screen 2, Label 2.

Hvis du refererer til et kontrolelement fra det første skærmbillede i appen på det andet skærmbillede, er der ikke et ydeevnehit, fordi det første skærmbillede allerede er indlæst. Det kan faktisk være en god ting, fordi appen er beskrivende i stedet for at bruge variabler.

Hvis du refererer til kontrolelementer, der endnu ikke er indlæst, f.eks. det første skærmbillede, der refererer til et kontrolelement, der er navngivet Label 3 fra skærmbillede 3, indlæser appen skærmbilledet i hukommelsen.

Aktivere DelayOutput til tekstkontrolelementer

DelayOutput-indstillingen, når den er angivet til sand, registreres brugerinput med et halvt sekunds forsinkelse. Dette kan være nyttigt, hvis du vil udskyde krævende handlinger, indtil brugeren afslutter tekstindtastningen (dvs. til filtrering, når inputtet bruges i andre formler).

Hvis du f.eks. vil have et galleri, hvis elementer filtreres, afhængigt af hvad brugeren indtaster i kontrolelementet TextInput:

• Når DelayOutput er angivet til false, som er standard, filtreres galleriet, så snart der skrives tekst. Hvis du har et galleri med mange elementer, sænkes ydeevnen ved at genindlæse galleriet med ændringer med det samme. Det er bedre at vente lidt. Det er praktisk, når du bruger TextInput for en søgestreng (se Søgning eller de nye StartsWith-funktioner).

• Når DelayOutput er angivet til sand, er der en kort forsinkelse, før ændringerne registreres. Dette giver dig tid til at skrive færdig. Forsinkelsen fungerer godt sammen med egenskaben TextInput.OnChange. Hvis du har handlinger, der er knyttet til ændringer, skal de først udløses, når du er færdig med at skrive i feltet.

Delegering og behandling på serversiden

Delegering

Delegering i Power Apps er et koncept, der henviser til appens mulighed for at aflaste bestemte operationer til den underliggende datakilde i stedet for at behandle operationerne i sig Power Apps selv. Ved hjælp af delegering i Power Apps kan udviklere oprette mere effektive og skalerbare programmer, der fungerer godt, selv i scenarier, der involverer store datasæt. Det er vigtigt at være opmærksom på delegeringsbegrænsninger for bestemte datakilder og handlinger og at designe apps i overensstemmelse hermed for at opnå optimal ydeevne.

![NOTE] Ikke alle funktioner kan uddelegeres. Henvis venligst til Om delegering for at få mere at vide om delegering.

Delegering har flere fordele, f.eks. optimering af forespørgsler, og tilføjer understøttelse af store datasæt. Hvis kildedataene ændres ofte, er delegering desuden med til at holde dataene opdaterede.

Reducer API-opkald til datakilde

Nogle gange kan det virke praktisk at oprette samlinger ved at udføre sammenføjninger i din lærredapp. Her er et eksempel:

I dette eksempel findes der to tabeller: Drivere og Lastbiler. Koden opretter en samling af chauffører og lastbiloplysninger, og for hver lastbil ringer den til chaufføren, der ejer lastbilen.

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

At udføre en sådan sammenføjning i lærredsapp kan generere mange opkald til datakilden, hvilket fører til langsomme indlæsningstider.

En bedre fremgangsmåde er:

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

I realtidsscenariet kan du reducere indlæsningstiderne fra fem minutter til under 10 sekunder ved at fastsætte dataene ved kilden.

Behandling på serversiden

Med forskellige datakilder, f.eks. SQL og Dataverse kan du delegere databehandling, f.eks. filtre og opslag, til datakilden. I SQL Server kan du oprette visninger, der er defineret af en forespørgsel. I Dataverse kan du oprette low-code plugins til at behandle data på serveren og kun returnere de endelige resultater til din lærredsapp.

Uddelegering af databehandling til serveren kan forbedre ydeevnen, reducere kode på klientsiden og gøre din app nemmere at vedligeholde.

Få mere at vide om plug-ins i Dataverse.

Optimerede forespørgselsdatamønstre

Brug eksplicit valg af kolonne

Funktionen ECS (Explicit Column Selection) er som standard slået til for alle nye apps. Hvis den ikke er slået til for din app, skal du slå den til. ECS reducerer automatisk antallet af kolonner, der hentes, til kun dem, der bruges i appen. Hvis ECS ikke er slået til, får du muligvis flere data, end du har brug for, hvilket kan påvirke ydeevnen. Når en app henter data gennem samlinger, kan den oprindelige kilde til en kolonne nogle gange gå tabt. ECS taber kolonner, hvis det ikke kan se, at de bruges. Hvis du vil tvinge ECS til at beholde en manglende kolonne, skal du bruge PowerFx-udtrykket ShowColumns efter en samlingsreference eller i et kontrolelement.

Undgå at kalde Power Automate for at udfylde en samling

En almindelig praksis er at bruge Power Automate til at hente og udfylde samlinger i Power Apps. Selvom denne fremgangsmåde er gyldig, er der situationer, hvor den måske ikke er det mest effektive valg. At kalde Power Automate medfører en overhead i form af netværksforsinkelse og tilføjer en ydelsesomkostning på 0,6 sekunder for at iværksætte Power Automate flowet.

Overforbrug af Power Automate-workflows kan også føre til grænser for eksekvering og throttling. Du bør derfor altid vurdere afvejninger mellem netværks latenstid og ydeevneomkostninger.

Eliminer N+1 problemet

N+1-problemet er et almindeligt problem i databaseforespørgsler, hvor der i stedet for at hente alle de påkrævede data i en enkelt forespørgsel oprettes flere ekstra forespørgsler for at hente relaterede data. Dette kan medføre ydeevneproblemer, da hver ekstra forespørgsel medfører overhead.

Et simpelt opkald som dette for at indlæse en samling kan generere N+1-kald til datakilde.

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

I forbindelse med apps og gallerier på lærred kan problemet N+1 opstå, når du arbejder med datakilder og gallerier, der viser relaterede poster. Problemet opstår typisk, når der oprettes flere forespørgsler for hvert enkelt element, der vises i galleriet, hvilket medfører en ydeevneflaskehals.

Brug Visningsobjekter i SQL Server til at undgå problemer med N+1-forespørgsler, eller rediger brugergrænsefladen for at undgå at udløse N+1-scenariet.

Dataverse Henter automatisk de påkrævede data i relaterede tabeller, og du kan vælge kolonnerne fra relaterede tabeller.

ThisItem.Account.'Account Name'

Hvis RelatedDataSource' størrelse er lille (<500 poster), kan du cache den i en samling og bruge samlingen til at køre Lookup (N+1) forespørgselsscenarie.

Begrænsning af pakkestørrelsen

Selvom Power Apps der er meget, der optimerer indlæsningen af apps, kan du gøre noget for at reducere dit apps fodaftryk. Et reduceret fodaftryk er især vigtigt for brugere af ældre enheder, eller brugere i områder, hvor der er højere ventetid eller reduceret båndbredde.

• Evaluer de medier, der er integreret i din app. Hvis der ikke bruges noget, skal du slette det.

• Integrerede billeder kan være for store. I stedet for PNG-filer kan du se, om du kan bruge SVG-billeder. Vær dog forsigtig med at bruge tekst i SVG-billeder, da den anvendte skrifttype skal installeres på klienten. En god løsning, når du har brug for at få vist tekst, er at overlejre en tekstetiket over et billede.

• Evaluer, om opløsningen passer til den formfaktor. Opløsningen for en mobilapp behøver ikke at være så høj som opløsningen på en desktopapp. Prøv at finde den rette balance i billedkvalitet og -størrelse.

• Hvis du har ubrugte skærme, skal du slette dem. Vær forsigtig med ikke at slette skjulte skærme, som kun appudviklere eller administratorer bruger.

• Vurdér, om du forsøger at passe for mange arbejdsprocesser ind i én app. Har du f.eks. både administratorskærme og klientskærme i den samme app? Hvis det er tilfældet, skal du overveje at opdele dem i individuelle apps. Denne fremgangsmåde vil også gøre det nemmere for flere personer at arbejde med appene på samme tid, og den begrænser "effektområde" (mængden af test), når appændringer kræver en fuld test.

Optimer ForAll

Funktionen ForAll i Power Apps bruges til at iterere gennem en tabel med poster og anvende en formel eller et sæt formler på hver post. Mens selve funktionen er alsidig, kan brugen af ForAll-funktionen hurtigt gøre din app mindre performant.

ForAll-funktionen er en enkel sekventiel funktion i stedet for en samtidig funktion. Derfor ser den kun på én post ad gangen, får resultatet og fortsætter til den næste, indtil den har gennemgået alle poster i sit omfang.

Undgå at indlejre ForAll for enhver pris. Dette kan medføre eksponentielle gentagelser og en betydelig påvirkning af ydeevnen.

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

Batchopdateringer til databasen

ForAll + Patch kan være én fremgangsmåde til batchopdatering af databasen. Vær dog forsigtig, når du bruger rækkefølgen for For alle og Patch.

Følgende funktion:

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

Klarer sig bedre end:

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

Næste trin

Retningslinjer for fejlhåndtering