Kodoptimering

I takt med att arbetsyteappar utvecklas för att uppfylla olika affärsbehov är det viktigt att prestandan hålls optimal. Datahantering, design av användargränssnitt och appfunktioner kräver alla en noggrann metod för kodoptimering.

När arbetsyteapparna blir mer komplexa kan du stöta på problem med datahämtning, formelkomplexitet och renderingshastighet. Att balansera stark funktionalitet och ett responsivt användargränssnitt innebär att du behöver ett systematiskt tillvägagångssätt för kodoptimering.

Power Fx formeloptimering

Funktionen With

With-funktionen utvärderar en formel för en enskild post. Formeln kan beräkna ett värde eller utföra åtgärder, som att t.ex. modifiera data eller arbeta med en anslutning. Use With för att göra komplexa formler lättare att läsa genom att dela upp dem i mindre namngivna delformler. Dessa namngivna värden fungerar som enkla lokala variabler begränsade till omfattningen av With. Använda With är bättre än kontextuella eller globala variabler eftersom den är fristående, lätt att förstå och fungerar i alla deklarerande formelkontexter. Läs mer om With-funktionen.

Funktionen Concurrent

Funktionen Concurrent gör att flera formler i samma egenskap kan utvärderas samtidigt om de har anslutningsprogram eller Dataverse-anrop. Normalt utvärderas flera formler samtidigt när du kedjar dem med operatorn ; (semikolon). Med Concurrent utvärderar appen alla formler i en egenskap samtidigt, även efter att operatorn ; har använts. Den här samtidigheten innebär att användarna väntar mindre på resultat. När dataanrop inte startar förrän de tidigare anropen slutförs måste programmet vänta på summan av alla begärandetider. Om dataanrop startar på samma gång behöver programmet endast vänta på den längsta begärandetiden. Läs mer om Concurrent-funktionen.

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

Coalesce-funktionen

Funktionen Coalesce utvärderar argumenten i ordning och returnerar det första värdet som inte är blank eller en tom sträng. Använd den här funktionen om du vill ersätta ett blank-värde eller en tom sträng med ett annat värde, men lämna icke blank och icke-tomma strängvärden oförändrade. Om alla argument är tomma eller tomma strängar returnerar funktionen tomt. Coalesce är ett bra sätt att konvertera tomma strängar till tomma värden.

Till exempel: '

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

Kräver värde 1 och värde 2 som beräknas två gånger. Den här funktionen kan reduceras till:

Coalesce(value1, value2)

Funktionen IsMatch

Funktionen IsMatch testar om en textsträng matchar ett mönster som består av vanliga tecken, fördefinierade mönster eller ett reguljärt uttryck. Läs mer om IsMatch-funktionen.

Den här formeln matchar till exempel ett socialförsäkringsnummer i USA:

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

Förklaring av det reguljära uttrycket:

\\d matchar en siffra (0-9).

{3} anger att det föregående siffermönstret (\d) inträffar exakt tre gånger.

- Matchar bindestreckstecknet.

{2} anger att det föregående siffermönstret (\d) inträffar exakt två gånger.

{4} anger att det föregående siffermönstret (\d) inträffar exakt fyra gånger.

Fler exempel på IsMatch.

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

Optimera appen OnStart

Egenskapen OnStart för appar har en viktig roll när det gäller att definiera åtgärder som inträffar när appen lanseras. Med den här egenskapen kan apputvecklare utföra globala initieringsuppgifter, konfigurera variabler och utföra åtgärder som endast inträffar en gång under appens startprocess. Att förstå och effektivt använda OnStart-egenskapen är avgörande för att skapa responsiva och effektiva arbetsyteappar.

Vi rekommenderar att du förenklar funktionen App.OnStart genom att migrera olika inställningar till namngivna formler. Namngivna formler, särskilt de som konfigurerats tidigt i appens livscykel, visar sig vara en fördel. Dessa formler kan initiera variabler baserat på dataanrop, vilket ger en renare och mer ordnad struktur för koden. Mer information Skapa stora och komplexa arbetsyteappar – Power Apps | Microsoft Learn.

Obs

OnStart-egenskapen är Imperative. Det är en ordnad lista över arbete som måste göras innan den första skärmen visas. Eftersom den är så specifik med inte bara vad som behöver göras,utan även när arbetet måste utföras baserat på order, begränsar den omordnings- och uppskjutningsoptimeringar som annars kunde göras.

Startskärm

Om App.OnStart innehåller funktionsanropet Navigate även om det är en If-funktion och sällan anropas, måste vi slutföra appkörningen. OnStart innan visar appens första skärm.  App.StartScreen är det nya deklarativa sättet att ange vilken skärm som visas först, som inte blockerar optimeringar.

När egenskapen StartScreen anges visas den första skärmen innan App.OnStart har slutförts. App.StartScreen declares vilket skärmobjekt som visas först utan att det krävs förbearbetning.

I stället för att skriva kod såsom:

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

Ändra koden till:

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

Mer information finns i <https://Power Apps.microsoft.com/en-us/blog/app-startscreen-a-new-declarative-alternative-to-navigate-in-app-onstart/>.

Varning

Undvik beroenden mellan och StartScreen och OnStart. Om du refererar till en namngiven formel som i sin tur refererar till en global variabel kan det orsaka ett konkurrenstillstånd som StartScreen inte tillämpas korrekt. Notera: vi bör inte ha beroenden mellan StartScreen och OnStart. Vi blockerar referens till globala variabler i StartScreen, men vi kan referera till en namngiven formel som i sin tur refererar till en global variabel, och som kan orsaka ett konkurrenstillstånd där StartScreen inte tillämpas korrekt.

Namngivna formler

Namngivna formler är statiska eller konstanter, som kan definieras i avsnittet App.Formulas. När de har deklarerats i App.Formulas kan de användas var som helst i appen och värdet är alltid uppdaterat. Namngivna formler i Power Apps möjliggör definition av värden eller uppsättningar med värden som automatiskt hanteras och uppdateras av plattformen. Den här funktionen överför ansvaret för värdeberäkning och underhåll från utvecklaren till Power Apps, vilket förenklar utvecklingsprocessen. Namngivna formler i Power Apps är en kraftfull funktion som avservärt kan förbättra appprestanda och underhåll.

Namngivna formler kan även åtgärda appteman som deklarerar. I många fall där företagsappar skapas vill vi att appen har ett enhetligt utseende och en enhetlig användarupplevelse. För att skapa ett tema finns det tio- och hundratals variabler som måste deklareras i App OnStart. Det här ökade kodlängden och initieringstiden för appen.

Modern kontroller kan också hjälpa mycket teman och till att minska kundskriven logik för att hantera dem. Moderna kontroller är för närvarande i förhandsversion.

Följande kod i App.OnStart kan exempelvis flyttas till App.Formulas, vilket minskar starttiden för deklaration av globala 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 flyttas till App.Formulas enligt följande:

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

Ett annat exempel är inställningen för Lookups. Här krävs en ändring i en Lookup-formel för att hämta användarinformationen från Office 365, i stället för Dataverse. Det finns bara en plats där ändringen krävs utan att koden ändras överallt.

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

Dessa formler förkroppsligar beräkning. De uttrycker processen för att fastställa UserEmail, UserInfoUserTitle och UserPhone grundade på andra värden. Logiken är inkapslad och möjliggör bred användning i appen och går att ändra på en enskild plats. Anpassningsbarheten sträcker sig från Dataverse Användare-tabeller till Office 365-anslutningsprogram utan att det krävs ändringar i formler spridda i appen.

En annan metod är att optimera countRows.

varListItems = CountRows(SampleList)

Med Set-funktionen måste variabeln varListItems initieras med det första antalet rader i exempellistan och anges igen när listobjekten lagts till eller tagits bort. Med namngivna formler uppdateras varListitems-variablerna automatiskt när data ändras.

Namngivna formler i egenskapen App.Formulas ger en mer flexibel och deklarativ metod för hantering av värden och beräkningar i hela appen, med fördelar när det gäller oberoende timing, automatiska uppdateringar, underhåll och oföränderliga definitioner jämfört med att enbart förlita sig på App.OnStart.

Aspekt	Namngivna formler (App.Formulas)	App.OnStart
Oberoende timing	Formler finns direkt tillgängliga, kan beräknas i valfri ordning.	Variabler kan introducera tidsberoenden som påverkar tillgängligheten.
Automatiska uppdateringar	Formeln uppdateras automatiskt när beroenden ändras.	Variabler anges en gång vid start. Manuella uppdateringar kan behövas.
Underhållsmöjlighet	Centraliserad formler på en samma plats förbättrar underhåll.	Spridda variabler kan kräva att söka efter och uppdatera dem på många platser.
Oföränderliga definitioner	Formeldefinitionerna i App.Formulas är oföränderliga.	Variabelvärden kan känsliga för oavsiktliga ändringar.

Användardefinierade funktioner

Användardefinierade funktioner i Power Apps Authoring Studio gör det möjligt för användare att skapa en egen anpassad funktion.

Om du vill använda den här funktionen aktiverar du Användardefinierad funktion (UDF:er) under förhandsgranskningsinställningar. Förhandsgranskningsfunktionen ska inte användas i produktion, vilket är anledningen till att de är inaktiverade som standard, men kommer snart att bli allmänt tillgängliga.

Definiera en formel under App.Formulas enligt följande:

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

Koden fungerar så här:

• FunctionName används för att anropa funktionen

• Parameter är namnet på indata. Ett eller flera indata tillåts

• DataType är ett argument som skickas till funktionen måste matcha den här datatypen. Tillgängliga datatyper är Boolesk, Färg, Datum, Datumtid, Dynamisk, GUID, Hyperlänk, Text och Tid

• OutputDataType är utdatatypen där funktionen finns

• Formula är funktionens utdata

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

Används IfError för att implementera felhantering inom den definierade funktionen.

Anropa den definierade funktionen från text-/etikettkontrollen.

calcAreaOfCircle(Int(*TextInput1*.Text))

Obs

Det här är en experimentell funktion som kanske ändras. Vissa datatyper, till exempel poster och filter, stöds ännu inte.

Optimera variabler

Variabler definierar och anger lokala och globala värden som du använder i hela appen. Även om de är praktiska kan för många variabler göra din app mindre effektiv.

I följande exempel visas hur du anger en variabel för varje attribut för ett objekt, vilket kräver att du använder Set för varje egenskap.

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 mer effektiv metod är att bara använda egenskapen när du behöver den:

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

Använd sammanhangsvariabler och globala variabler med omsorg. Om en variabels omfång sträcker sig längre än en enda skärm använder du globala variabler i stället för kontextvariabler.

För många oanvända variabler ökar minnesanvändningen och kan göra appinitieringen långsammare. Resurser allokeras för dessa variabler även om du inte använder dem. Oanvända variabler ökar också komplexiteten i appens logik. Även om effekten kanske inte är allvarlig, är det en bra idé att hålla din Power App ren och organiserad för bättre prestanda och enklare utveckling.

Optimera samlingar

Samlingar är tillfälliga datalagringsstrukturer som du använder för att lagra och ändra data i en Power Apps-app. Men samlingar kan orsaka prestandakostnader om du använder dem för mycket. Begränsa din användning av samlingar och använd dem endast när det är nödvändigt.

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

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

Om du vill räkna poster i en lokal samling använder du CountIf i stället för Count(Filter()).

Använd den här vägledningen när du arbetar med samlingar:

Begränsa storleken och antalet samlingar. Eftersom samlingar är lokala för appen lagras de i den mobila enhetens minne. Ju fler datainsamlingar som finns, eller ju fler samlingar du använder, desto sämre prestanda. Använd funktionen ShowColumns för att endast hämta specifika kolumner. Lägg till Filter-funktionen för att endast få relevanta data.

Följande exempelfunktion returnerar hela datauppsättningen.

ClearCollect(colDemoAccount, Accounts);

Jämför detta med följande kod, som endast returnerar specifika poster och kolumner:

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

Det här exemplet returnerar följande datauppsättning:

Ange uppdateringsfrekvens för datakälla. Om du lägger till nya poster i samlingen uppdaterar du den eller samlar in den för att hämta de nya eller ändrade posterna. Om flera användare uppdaterar datakällan uppdaterar du samlingen för att hämta de nya eller ändrade posterna. Fler uppdateringsanrop innebär mer interaktion med servern.

Cachelagra data i samlingar och variabler

En samling är en tabellvariabel som lagrar rader och kolumner med data, inte bara ett enda dataobjekt. Samlingar är användbara av två huvudskäl: aggregering av data innan de skickas till datakällan och cachelagring av information för att undvika frekventa frågor. Eftersom samlingar matchar datakällans tabellstruktur och Power Apps kan du interagera med data effektivt, även när du är offline.

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

Ta bort oanvända variabler och media

Även om oanvända media och variabler kanske inte har någon betydande inverkan på appens prestanda är det viktigt att rensa appen genom att ta bort oanvända media eller variabler.

• Oanvända mediefiler ökar appens storlek, vilket kan göra appinläsningstiderna långsammare.

• Oanvända variabler ökar minnesanvändningen och kan göra appinitieringen något långsammare. Resurser allokeras för dessa variabler även om de inte används. För många oanvända variabler kan också göra appens logik mer komplex.

• Använd App Checker för att granska oanvända media och variabler.

Optimera skärmar och kontroller

Undvik att korsreferera kontroller

Kontroller som refererar till kontroller på andra skärmar kan göra inläsningen och navigeringen i appen långsammare. Om du gör detta kan appen tvingas läsa in de andra skärmarna omedelbart, i stället för att vänta tills användaren går till den skärmen. Korrigera detta problem genom att använda variabler, samlingar och navigeringssammanhang för att dela status över skärmar.

Appkontrollen i Power Apps Studio visar kontroller som är korsrefererade. Granska appkontrollen regelbundet för att åtgärda problemet.

Här är ett exempel på korsrefererade kontroller. I bilden nedan är kontrollen Galleri 1 korsrefererad till kontrollen Skärm 2, Etikett 2.

Om du refererar till en kontroll från den första skärmen i appen på den andra skärmen finns det ingen prestandaträff eftersom den första skärmen redan har lästs in. Detta kan faktiskt vara bra eftersom appen är deklarativ istället för att använda variabler.

Om du refererar till kontroller som inte har lästs in ännu, till exempel den första skärmen som refererar till en kontroll med namnet Label 3 från skärm 3, läser appen in skärmen i minnet.

Aktivera DelayOutput för alla textkontroller

När inställningen DelayOutput är satt till sant registreras användarinmatning efter en halv sekunds fördröjning. Detta är användbart om man vill senarelägga kostsamma åtgärder till dess att användaren är klar med textinmatning, t.ex. för filtrering när indata används i andra formler.

Till exempel för ett galleri vars objekt filtreras beroende på vad användaren anger i TextInput-kontrollen:

• Med DelayOutput inställt på false, vilket är standard, filtreras galleriet så snart någon text skrivs. Om du har ett galleri med många objekt går det långsammare att ladda om galleriet med ändringar direkt. Det är bättre att vänta lite. Det här är praktiskt när du använder TextInput för en söksträng (se Sök eller de nya StartsWith-funktionerna).

• När DelayOutput är inställt på true finns det en kort fördröjning innan ändringarna identifieras. Detta ger dig tid att skriva färdigt. Fördröjningen fungerar bra med egenskapen TextInput.OnChange. Om du har åtgärder som är kopplade till ändringar vill du inte att de ska utlösas förrän du har skrivit klart i fältet.

Delegering och bearbetning på serversidan

Delegering

Delegering i Power Apps är ett koncept som refererar till appens möjlighet att avlasta vissa åtgärder till underliggande datakälla i stället för att själv bearbeta åtgärderna i Power Apps . Genom att använda delegering i Power Apps kan utvecklare skapa effektivare och skalbara program som fungerar bra även om det rör sig om stora datauppsättningar. Det är viktigt att känna till delegeringsbegränsningar för specifika datakällor och -åtgärder och att utforma appar därefter för att uppnå optimal prestanda.

![OBS] Alla funktioner kan inte delegeras. Se Förstå delegering för mer information om delegering.

Delegering har flera fördelar, till exempel frågeoptimering och lägger till stöd för stora datauppsättningar. Om källdata ändras ofta kan delegeringen dessutom hålla alla data uppdaterade.

Minska antal API-anrop till datakällan

Ibland kan det vara praktiskt att skapa samlingar genom att utföra kopplingar i din arbetsyteapp. Här är ett exempel:

I det här exemplet finns det två tabeller: Drivers och Trucks. Koden skapar en samling förare och lastbilsinformation, och för varje lastbil anropar den föraren som äger 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)));

Att utföra en sådan koppling i arbetsyteappen kan generera många anrop till datakällan, vilket leder till långsamma inläsningstider.

En bättre metod är:

// 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 realtidsscenariot kan du minska laddningstiderna från fem minuter till under 10 sekunder genom att åtgärda data vid källan.

Bearbetning på serversidan

Med olika datakällor, till exempel SQL och Dataverse, kan du delegera databearbetning, till exempel filter och sökningar, till datakällan. I SQL Server kan du skapa vyer som definieras av en fråga. I Dataverse kan du skapa plugin-program med låg kod för att bearbeta data på servern och endast returnera slutresultatet till din arbetsyteapp.

Genom att delegera databearbetning till servern kan du förbättra prestandan, minska koden på klientsidan och göra appen enklare att underhålla.

Läs mer om plugin-program i Dataverse.

Optimera frågedatamönster

Använd explicit kolumnval

Funktionen Explicit kolumnval (ECS) är aktiverad som standard för alla nya appar. Om den inte är aktiverad för appen aktiverar du den. ECS minskar automatiskt antalet kolumner som hämtas till endast de som används i appen. Om ECS inte är aktiverat kan du få mer data än du behöver, vilket kan påverka prestandan. Ibland, när en app hämtar data via samlingar, kan den ursprungliga källan till en kolumn gå förlorad. ECS tar bort kolumner om den inte kan se att de används. Om du vill tvinga ECS att behålla en saknad kolumn använder du PowerFx-uttrycket ShowColumns efter en samlingsreferens eller i en kontroll.

Undvik att anropa Power Automate för att fylla i en samling

En vanlig metod är att använda Power Automate för att hämta och fylla i samlingar i Power Apps. Den här metoden är visserligen giltig men det finns situationer där det kanske inte är det effektivaste valet. Anrop till Power Automate ger belastar nätverkets svarstid och lägger till en prestandakostnad på 0,6 sekunder för att skapa en instans av Power Automate-flödet.

Överanvändning av Power Automate-flöden kan också leda till körningsbegränsningar och begränsning. Utvärdera därför alltid skillnaderna mellan nätverkssvarstid och prestandakostnad.

Eliminera N+1-problem

N+1-problemet är ett vanligt problem i databasfrågor där flera extra frågor skapas för hämtning av relaterade data i stället för att hämta all nödvändig data med en enda fråga. Det kan leda till prestandaproblem eftersom varje extra fråga skapar belastning.

Ett enkelt anrop som det här för att läsa in en samling kan generera N+1-anrop till datakällan.

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

När det gäller arbetsyteappar och gallerier kan N+1-problemet uppstå när du arbetar med datakällor och gallerier som visar relaterade poster. Problemet uppstår oftast när fler frågor görs för varje objekt som visas i galleriet, vilket leder till en flaskhals i prestanda.

Använd Vy-objekt i SQL Server för att undvika problem med N+1-fråga eller ändra användargränssnittet för att undvika att utlösa N+1-scenariot.

Dataverse hämtar automatiskt data som krävs för relaterade tabeller och du kan välja kolumnerna i relaterade tabeller.

ThisItem.Account.'Account Name'

Om RelatedDataSourc-storleken är liten (<500-poster) kan du cachelagra den i en samling och använda samlingen för att driva uppslagsscenariot (N+1).

Begränsa paketstorleken

Även om Power Apps gör mycket för att optimera inläsningen av appar, kan du vidta steg för att minska fotavtrycket på dina appar. Minskat fotavtryck är särskilt viktigt för användare med äldre enheter eller användare på platser lång svarstid eller låg bandbredd.

• Utvärdera mediet som är inbäddat i appen. Om något inte används tar du bort det.

• Inbäddade bilder kan vara för stora. Kontrollera om det går att använda SVG-bilder i stället för PNG-filer. Var dock försiktig med att använda text i SVG-bilder eftersom teckensnittet som används måste installeras på klienten. En bra lösning om du måste visa text är att lägga en textetikett över en bild.

• Utvärdera om lösningen är lämplig för formfaktorn. Upplösningen för en mobilapp behöver inte vara lika hög som upplösningen för en datorapp. Prova dig fram till rätt balans mellan bildkvalitet och storlek.

• Ta bort oanvända skärmar. Var försiktig så att du inte tar bort dolda skärmar som bara apputvecklare eller administratörer använder.

• Utvärdera om du försöker lägga in för många arbetsflöden i en app. Har du till exempel både administratörsskärmar och klientskärmar i samma app? I så fall kan du överväga att dela in dem i enskilda appar. Den här metoden gör det också lättare för flera personer att arbeta med apparna samtidigt och den begränsar testernas omfattning när appens ändringar kräver ett fullständigt testpass.

Optimera ForAll

Funktionen ForAll i Power Apps används för att iterera genom en tabell med poster och tillämpa en formel eller uppsättning formler på varje post. Även om funktionen i sig är allsidig kan ForAll-funktionen snabbt göra appen mindre användbar.

ForAll-funktionen är en singulär sekventiell funktion i stället för en samtidig funktion. Därför tittar den bara på en post i taget, resultatet visas och går sedan vidare tills den har gått igenom alla poster i sin omfattning.

Undvik till varje pris att kapsla in ForAll. Det kan leda till exponentiella iterationer och markant påverkan på prestanda.

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

Batchuppdateringar av databas

ForAll + Patch kan vara en metod för batchuppdatering av databasen. Var dock försiktig när du använder ordningen ForAll och Patch.

Följande funktion:

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

Presterar bättre än:

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

Gå vidare

Riktlinjer för felhantering