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.

I takt med at lærredsapps bliver mere komplekse, kan du støde på problemer med datahentning, formelkompleksitet og gengivelseshastighed. Hvis du vil balancere stærk funktionalitet med en dynamisk brugergrænseflade, skal du bruge en systematisk tilgang til kodeoptimering.

Power Fx-formeloptimering

Dette afsnit indeholder de bedste fremgangsmåder til optimering af Power Fx-formler.

With-funktionen

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. With er bedre end kontekstvariabler eller globale variabler, fordi de er selvstændige, nemme at forstå og fungerer i en hvilken som helst deklarativ formelkontekst. Få mere at vide om funktionen With.

Concurrent funktion

Funktionen Concurrent gør det muligt at evaluere flere formler i den samme egenskab på samme tid, hvis de har connector- eller 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 tid 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 funktionen Concurrent.

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

Funktionen Coalesce

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. Få mere at vide om funktionen Coalesce.

Dette eksempel kræver value1 og value2 evalueres to gange:

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

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 funktionen IsMatch.

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 afgørende rolle i definitionen af handlinger, der opstår, 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å og effektivt bruge egenskaben OnStart til at oprette dynamiske og effektive lærredsapps.

Strømline funktionen App.OnStart ved at migrere variabelopsætninger til navngivne formler. Navngivne formler, især dem, der er konfigureret tidligt i appens livscyklus, er fordelagtige. Disse formler håndterer initialisering af variabler baseret på dataopkald, hvilket giver en renere og mere organiseret struktur for koden. Få mere at vide i Byg store og komplekse lærredsapps.

Start skærmbillede

Hvis App.OnStart indeholder et Navigate funktionskald, selvom det er i en If funktion og sjældent kaldes, skal appen fuldføre udførelsen af App.OnStart , før den viser den første skærm i appen.  App.StartScreen er en deklarativ måde at angive, hvilken skærm der skal vises først, og det blokerer ikke optimeringer.

Indstilling af StartScreen egenskaben viser det første skærmbillede, før App.OnStart er fuldført. App.StartScreen deklarerer, hvilket skærmobjekt der skal vises først, uden at der kræves nogen forbehandling.

I stedet for at skrive kode som:

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

Ændre koden til:

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

Flere oplysninger: App.StartScreen: et deklarativt alternativ til Navigate in App.OnStart.

Navngivne formler

Navngivne formler er statiske eller konstanter, der kan defineres i App.Formulas. Når de er erklæret i App.Formulas, kan de bruges overalt i appen, og deres værdier forbliver altid opdaterede. Med navngivne formler i Power Apps kan du definere værdier eller værdisæt, som platformen automatisk administrerer og opdaterer. Denne funktionalitet flytter ansvaret for værdiberegning og vedligeholdelse fra udvikleren til Power Apps og strømliner udviklingsprocessen. Navngivne formler i Power Apps er en effektiv funktion, der kan forbedre appens ydeevne og vedligeholdelse betydeligt.

Navngivne formler hjælper også med at erklære apptemaer. Når du bygger virksomhedsapps, ønsker du ofte, at appen har fælles temaer, der giver et ensartet udseende og en ensartet brugeroplevelse. Hvis du vil oprette et tema, skal du deklarere ti til hundredvis af variabler i App.OnStart. Denne erklæring øger kodelængden og appens initialiseringstid.

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.

Du kan f.eks. flytte følgende kode App.OnStart til App.Formulas, hvilket reducerer starttiden for globale variabelerklæringer.

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

Du kan flytte koden 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 i indstillingen Lookups. Her kræves der en ændring i en Lookup formel for at hente brugeroplysningerne fra Office 365 i stedet for Dataverse. Du skal kun foretage ændringen ét sted uden at ændre koden overalt.

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 funktionen Set skal du initialisere variablen varListItems med det første antal rækker på eksempellisten og angive den igen, når listeelementerne er tilføjet eller fjernet. Med navngivne formler opdateres variablen automatisk, efterhånden varListItems som dataene ændres.

Navngivne formler i App.Formulas egenskaben giver en mere fleksibel og deklarativ tilgang til administration af værdier og beregninger i hele appen. De giver fordele med hensyn til timinguafhængighed, automatiske opdateringer, vedligeholdelse og uforanderlige definitioner sammenlignet med udelukkende at være afhængige App.OnStartaf .

Brugerdefinerede funktioner

Brugerdefinerede funktioner i Power Apps Studio giver dig mulighed for at oprette dine egne brugerdefinerede funktioner.

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

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

Koden fungerer på følgende måde:

• FunctionName aktiverer funktionen.

• Parameter er navnet på inputtet. Du kan inkludere et eller flere input.

• DataType er den datatype, som det argument, der overføres til funktionen, skal matche. Tilgængelige datatyper omfatter boolesk, farve, dato, dato og klokkeslæt, dynamisk, GUID, link, tekst og klokkeslæt.

• OutputDataType er datatypen for funktionens uddata.

• Formula er funktionens output.

Bruges IfError til at implementere fejlhåndtering i den definerede funktion:

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

Kald den definerede funktion fra et tekst- eller etiketkontrolelement.

calcAreaOfCircle(Int(*TextInput1*.Text))

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. Hold din Power App ren og organiseret for at få bedre ydeevne og nemmere udvikling.

Optimer samlinger

Samlinger er midlertidige strukturer til datalagring, som du bruger til at gemme og manipulere data i en Power Apps app. Samlinger kan dog medføre problemer med ydeevnen. 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 fremgangsmåde, 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 denne funktion 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 påvirker appens ydeevne væsentligt, er det vigtigt at rydde op i din app ved at fjerne 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

Hvis du vil optimere skærmbilleder og kontrolelementer i Power Apps, skal du overveje følgende bedste fremgangsmåder.

Undgå at krydsreferere kontrolelementer

Kontrolelementer, der henviser til kontrolelementer på andre skærme, kan gøre indlæsning og navigation langsommere i apps. Denne fremgangsmåde kan tvinge appen til at indlæse de andre skærme i stedet for at vente, indtil brugeren går til den pågældende skærm. Du kan løse dette problem ved at bruge variabler, samlinger og navigationskontekst til at dele tilstand på tværs af skærme.

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

På følgende billede krydsrefereres kontrolelementet Gallery 1 i kontrolelementet Screen 2, Label 2.

Hvis du refererer til et kontrolelement fra det første skærmbillede i appen på den anden skærm, er der ingen ydeevne, fordi den første skærm allerede er indlæst. Denne funktionsmåde er faktisk nyttig, fordi appen er deklarativ i stedet for at bruge variabler.

Hvis du refererer til kontrolelementer, der endnu ikke er indlæst, f.eks. den første skærm, der refererer til et kontrolelement med navnet Label 3 fra skærm 3, indlæser appen skærmen i hukommelsen.

Aktivere DelayOutput til tekstkontrolelementer

Indstillingen DelayOutput skifter tilstanden til at registrere brugerinput efter en forsinkelse på et halvt sekund, når den er indstillet til true. Denne forsinkelse er nyttig til udskydelse af dyre handlinger, indtil brugeren er færdig med at skrive tekst, f.eks. filtrering, når input bruges i andre formler.

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

• Hvis du angiver DelayOutput til falsk, hvilket er standarden, filtreres galleriet, så snart der skrives tekst. Hvis du har et galleri med mange elementer, bliver ydeevnen langsommere, hvis du genindlæser galleriet med ændringer med det samme. Det er bedre at vente. Denne funktionsmåde er praktisk, når du bruger TextInput for en søgestreng eller funktionen StartsWith .

• Hvis du angiver DelayOutput til sand, er der en kort forsinkelse, før ændringerne registreres. Denne forsinkelse giver tid til at afslutte indtastning. 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

Brug af delegering og behandling på serversiden gør det muligt for din app at håndtere store datasæt effektivt ved at aflaste handlinger til datakilden.

Delegering

Delegering i Power Apps refererer til appens mulighed for at aflaste visse handlinger til den underliggende datakilde i stedet for at behandle handlingerne i selve Power Apps. Ved hjælp af delegering i Power Apps kan du oprette mere effektive og skalerbare programmer, der fungerer godt, selv i scenarier, der involverer store datasæt. Vær opmærksom på delegeringsbegrænsninger for bestemte datakilder og handlinger, og design din app i overensstemmelse hermed for at opnå optimal ydeevne.

Delegering har flere fordele, f.eks. optimering af forespørgsler og 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. Overvej følgende eksempel. I eksemplet er 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æsningstiden fra fem minutter til under 10 sekunder ved at rette 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

Optimering af, hvordan din app forespørger data, kan reducere indlæsningstiden betydeligt og forbedre den overordnede svartid.

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 fjerner kolonner, hvis det ikke kan afgøre, at de bruges. Hvis du vil tvinge ECS til at bevare en manglende kolonne, skal du bruge udtrykket ShowColumns Power Fx 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. Når du kalder Power Automate, tilføjes netværksventetid og en ydeevneomkostning på 0,6 sekunder for at instantiere Power Automate-flowet.

Overforbrug af Power Automate-workflows kan også føre til grænser for eksekvering og throttling. Evaluer altid afvejninger mellem netværksventetid 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 problem kan medføre problemer med ydeevnen, da hver ekstra forespørgsel medfører ekstra omkostninger.

Et simpelt kald som dette for at indlæse en samling kan generere N+1-kald til datakilden:

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

I forbindelse med lærredsapps og gallerier kan N+1-problemet opstå, når du arbejder med datakilder og gallerier, der viser relaterede dataregistre. Problemet opstår typisk, når der foretages flere forespørgsler for hvert enkelt element i galleriet, hvilket fører til en flaskehals for ydeevnen.

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ørrelsen er lille (færre end 500 poster), skal du cachelagre den i en samling og bruge samlingen til at køre forespørgselsscenariet Opslag (N+1).

Begræns pakkestørrelsen

Selvom Power Apps optimerer indlæsning af apps, kan du tage skridt til at reducere fodaftrykket for dine apps. Et reduceret fodaftryk er især vigtigt for brugere af ældre enheder eller brugere i landestandarder, 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 f.eks. være for store. I stedet for PNG-filer kan du se, om du kan bruge SVG-billeder. Vær forsigtig med at bruge tekst i SVG-billeder, da skrifttypen skal være installeret på klienten. En løsning, når du har brug for at vise tekst, er at overskrive 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 gør det også nemmere for flere personer at arbejde på apps på samme tid, og den begrænser "blast radius" (testmængde), når appændringer kræver et komplet testpas.

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. Selvom selve funktionen er alsidig, kan forkert brug af funktionen ForAll hurtigt gøre din app mindre effektiv.

Funktionen ForAll er en enkeltstående sekventiel funktion i stedet for en samtidig funktion. Derfor ser den kun på én post ad gangen, henter resultatet og fortsætter derefter til den næste post, indtil den gennemgår alle poster i dens omfang.

Undgå indlejring ForAll. Denne praksis kan føre til eksponentielle gentagelser og påvirke ydeevnen betydeligt.

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

Batchopdatering af databasen

Du kan bruge ForAll og Patch til at batchopdateringen af databasen. Vær dog forsigtig, når du bruger rækkefølgen af ForAll og Patch.

Følgende funktion er den bedste fremgangsmåde, f.eks.:

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

følgende fremgangsmåde er mindre effektiv:

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

Næste trin