Megosztás a következőn keresztül:

Kód optimalizálása

Ahogy a vászonalapú alkalmazások a különböző üzleti igényeknek megfelelően fejlődnek, a teljesítmény optimális megőrzése kritikus fontosságú. Az adatkezelés, a felhasználói felület kialakítása és az alkalmazás funkcionalitása mind gondos megközelítést igényel a kódoptimalizáláshoz.

A vászonalapú alkalmazások összetettebbé válásával problémákba ütközhet az adatok lekérésével, a képletek összetettségével és a megjelenítési sebességgel kapcsolatban. Az erős funkciók rugalmas felhasználói felülettel való egyensúlyba hozásához használjon szisztematikus megközelítést a kódoptimalizáláshoz.

Power Fx képletek optimalizálása

Ez a szakasz a Power Fx-képletek optimalizálásának ajánlott eljárásait ismerteti.

With függvény

A With függvény egyetlen rekord képletét értékeli ki. A képlet kiszámíthat egy értéket, vagy műveleteket hajthat végre, például módosíthatja az adatokat vagy dolgozhat egy kapcsolattal. With Az összetett képletek könnyebb olvashatóságát teszi lehetővé, ha kisebb, elnevezett alképletekre osztja őket. Ezek az elnevezett értékek egyszerű helyi változókként működnek, amelyek hatókörére korlátozódnak With. With jobb, mint a környezet vagy a globális változók, mert önálló, könnyen érthető, és bármilyen deklaratív képletkörnyezetben működik. További információ a With függvényről.

Képernyőkép a With függvényt használó Power Fx-képletről.

Párhuzamos funkció

A Concurrent függvény lehetővé teszi, hogy ugyanabban a tulajdonságban több képlet is egyszerre legyen kiértékelve, ha összekötő- vagy Dataverse-hívásokkal rendelkeznek. Általában több képletet értékel ki egyszerre, amikor a ; (pontosvessző) operátorral összefűzi őket. ConcurrentAz alkalmazás egyszerre értékeli ki a tulajdonság összes képletét, még az ; operátor használata után is. Ez az egyidejűség azt jelenti, hogy a felhasználók kevesebb időt várnak az eredményekre. Ha az adathívások csak az előző hívások befejezéséig indulnak el, az alkalmazás megvárja az összes kérési idő összegét. Ha az adathívások egyszerre kezdődnek, az alkalmazás csak a leghosszabb kérési időt várja. További információ az Egyidejű függvényről.

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

Coalesce függvény

A Coalesce függvény sorrendben értékeli ki az argumentumait, és visszaadja az első értéket, amely nem üres vagy üres karakterlánc. Ezzel a függvénnyel üres értéket vagy üres sztringet cserélhet le egy másik értékre, de a nem üres és nem üres karakterláncértékeket változatlanul hagyhatja. Ha az összes argumentum üres vagy üres karakterlánc, a függvény üres értéket ad vissza. Coalesce jó módszer az üres karakterláncok üres értékekké alakítására. További információ a Coalesce függvényről.

Ez a példa esetében value1 és value2 értékelésére kétszer van szükség.

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

Ez a funkció a következőkre csökkenthető:

Coalesce(value1, value2)

IsMatch függvény

A IsMatch függvény azt vizsgálja, hogy egy szöveges karakterlánc megfelel-e egy közönséges karakterekből, előre definiált mintákból vagy reguláris kifejezésekből álló mintának. További információ az IsMatch függvényről.

Ez a képlet például egy United States társadalombiztosítási számnak felel meg:

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

A reguláris kifejezés magyarázata:

  • \\d Bármely számjegyre illeszkedik (0-9).

  • {3} Megadja, hogy az előző számjegyminta (\d) pontosan háromszor forduljon elő.

  • - Megfelel a kötőjel karakternek.

  • {2} Megadja, hogy az előző számjegyminta (\d) pontosan kétszer forduljon elő.

  • {4} Megadja, hogy az előző számjegyminta (\d) pontosan négyszer forduljon elő.

További példák: IsMatch:

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

Alkalmazás optimalizálása OnStart

A OnStart vászonalapú alkalmazások tulajdonsága kulcsfontosságú szerepet játszik az alkalmazás indításakor előforduló műveletek meghatározásában. Ez a tulajdonság lehetővé teszi az alkalmazásfejlesztők számára, hogy globális inicializálási feladatokat hajtsanak végre, változókat állítsanak be, és olyan műveleteket hajtsanak végre, amelyeknek csak egyszer kell megtörténniük az alkalmazás indítási folyamata során. Ismerje meg és hatékonyan használja a OnStart tulajdonságot a rugalmas és hatékony vászonalapú alkalmazások létrehozásához.

Egyszerűsítse a App.OnStart függvényt azáltal, hogy a változók beállításait nevesített képletekbe migrálja. A nevesített képletek, különösen az alkalmazás életciklusának korai szakaszában konfigurált képletek előnyösek. Ezek a képletek kezelik a változók inicializálását az adathívások alapján, így tisztább és szervezettebb struktúrát biztosítanak a kód számára. További információ a nagyméretű és összetett vászonalapú alkalmazások készítéséről.

Megjegyzés

A OnStart tulajdonság elengedhetetlen. Ez egy rendezett munkalista, amelyet az első képernyő megjelenése előtt el kell végezni. Mivel ez nemcsak megmondja, mit kell tenni, hanem azt is, hogy mikor kell elvégezni a munkát a sorrend alapján, ez korlátozza az átrendezési és halasztási optimalizálásokat, amelyeket különben el lehetne végezni.

Kezdőképernyő

Ha a App.OnStart függvényhívást Navigate tartalmazza, még akkor is, ha az egy If függvényben van és ritkán hívják meg, az alkalmazásnak be kell fejeznie App.OnStart futását, mielőtt megjeleníti az alkalmazás első képernyőjét.  App.StartScreen deklaratív módon jelezheti, hogy melyik képernyő jelenjen meg először, és nem blokkolja az optimalizálást.

A tulajdonság beállítása StartScreen az első képernyőt jeleníti meg, mielőtt App.OnStart befejeződik. App.StartScreen Deklarálja, hogy melyik képernyőobjektum jelenjen meg először előfeldolgozás nélkül.

Ahelyett, hogy olyan kódot írna, mint:

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

Módosítsa a kódot a következőre:

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

További információ: App.StartScreen: deklaratív alternatíva az App.OnStartban való navigáláshoz.

Figyelmeztetés:

Kerülje a függőségeket StartScreen és OnStart között. Amikor egy nevesített képlet egy globális változóra hivatkozik, az olyan versenyfeltételt okozhat, amely miatt StartScreen nem kerül helyesen alkalmazásra.

Ne hozzon létre függőségeket a StartScreen és a OnStart között. Míg az alkalmazás letiltja a globális változókra való hivatkozásokat, hivatkozhat egy nevesített StartScreenképletre, amely viszont egy globális változóra hivatkozik. Ez a megközelítés olyan versenyhelyzetet okozhat, amelyben a rendszer nem megfelelően alkalmazza a StartScreen módszert.

Nevesített képletek

Az elnevezett képletek statikusak vagy állandók, amelyek a következőben App.Formulasdefiniálhatók: . A deklarációt App.Formulaskövetően az alkalmazás bármely pontján használhatók, és az értékük mindig naprakész marad. A Power Apps nevesített képletei lehetővé teszik olyan értékek vagy értékkészletek definiálását, amelyeket a platform automatikusan kezel és frissít. Ez a funkció áthelyezi az értékszámítás és -fenntartás felelősségét a fejlesztőtől a Power Apps -re, ezzel egyszerűsítve a fejlesztési folyamatot. A Power Apps nevesített képletei olyan hatékony funkciók, amelyek jelentősen javítják az alkalmazások teljesítményét és karbantarthatóságát.

Az elnevezett képletek az alkalmazástémák deklarálásában is segítenek. Vállalati alkalmazások létrehozásakor gyakran szeretné, hogy az alkalmazás olyan gyakori témákkal rendelkezzen, amelyek egységes megjelenést és felhasználói élményt biztosítanak. Téma létrehozásához több tíz-száz változót kell deklarálnia a következőben App.OnStart: . Ez a deklaráció növeli a kód hosszát és az alkalmazás inicializálási idejét.

A modern vezérlők is jelentősen segíthetnek a tematizálásban, és csökkenthetik az ügyfél által írt logikát a témák kezeléséhez. A modern vezérlők jelenleg előzetes verzióban érhetők el.

A kódot például áthelyezheti helyre, ami csökkenti a globális változódeklarációk futtatási kezdési idejét.

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

Az alábbi módon viheti át a kódot App.Formulas:

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

Egy másik példa a beállítás Lookups. Itt egy Lookup képletben módosításra van szükség ahhoz, hogy a felhasználói adatokat a Dataverse helyett Office 365-ból szerezze be. A módosítást csak egy helyen kell elvégeznie anélkül, hogy mindenhol módosítaná a kódot.

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

Ezek a képletek megtestesítik a számítás lényegét. Megfogalmazzák a meghatározás UserEmail folyamatát, UserInfo, UserTitle, és UserPhone más értékek alapján. Ez a logika be van ágyazva, lehetővé téve az alkalmazás széles körű használatát, és egyetlen helyen módosítható. Az alkalmazkodóképesség kiterjed a Dataverse Users tábláról a Office 365 összekötőre való váltásra anélkül, hogy az alkalmazáson belül szétszórt képleteket módosítania kell.

Egy másik megközelítés lehet az, hogy optimalizáljuk countRows.

varListItems = CountRows(SampleList)

Set A függvényben inicializálnia kell a változót varListItems a mintalistában szereplő sorok kezdeti számával, majd a listaelemek hozzáadása vagy eltávolítása után újra be kell állítania. Nevesített képletek esetén az adatok változásakor a varListItems változó automatikusan frissül.

A App.Formulas tulajdonság nevesített képletei rugalmasabb és deklaratívabb megközelítést biztosítanak az értékek és számítások alkalmazáson belüli kezeléséhez. Előnyöket kínálnak az időzítéstől való függetlenség, az automatikus frissítések, a karbantarthatóság és a változtathatatlan definíciók tekintetében, összehasonlítva a kizárólag App.OnStart való támaszkodással.

Tulajdonság Névvel ellátott képletek (App.Formulas) App.OnStart
Időzítés függetlensége A képletek azonnal elérhetők, és bármilyen sorrendben kiszámíthatók. A változók olyan időzítési függőségeket eredményezhetnek, amelyek befolyásolják a rendelkezésre állást.
Automatikus frissítések A képletek automatikusan frissülnek, ha a függőségek megváltoznak. A változók az indítás során egyszer vannak beállítva; manuális frissítésekre lehet szükség.
Karbantarthatóság Az egy helyen található központosított képletek javítják a karbantarthatóságot. A szétszórt változók több helyen meg kell keresni és frissíteni.
Nem módosítható definíciók A App.Formulas képletdefiníciók nem módosíthatók. A változóértékek érzékenyek lehetnek a véletlen változásokra.

Felhasználó által definiált függvények

A Power Apps Studio definiált függvényei lehetővé teszik saját egyéni függvények létrehozását.

Definiáljon egy képletet az alábbiak szerint App.Formulas :

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

A kód a következőképpen működik:

  • FunctionName meghívja a függvényt.

  • Parameter a bemenet neve. Egy vagy több bemenetet is megadhat.

  • DataType az az adattípus, amelyet a függvénynek átadott argumentumnak meg kell egyeznie. Az elérhető adattípusok közé tartozik a logikai érték, a szín, a dátum, a dátum és idő, a dinamikus, a GUID, a hivatkozás, a szöveg és az idő.

  • OutputDataType a függvény kimenetének adattípusa.

  • Formula a függvény kimenete.

Használja a IfError elemet a hibakezelés implementálásához egy definiált függvényben:

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

A definiált függvény meghívása szöveg- vagy címkevezérlőből.

calcAreaOfCircle(Int(*TextInput1*.Text))

Változók optimalizálása

A változók határozzák meg és állítják be az alkalmazásban használt helyi és globális értékeket. Bár kényelmesek, a túl sok változó használata kevésbé hatékonysá teheti az alkalmazást.

Az alábbi példa bemutatja, hogyan állíthat be változót egy objektum minden egyes attribútumához, amihez minden tulajdonság esetében Set használata szükséges.

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

Hatékonyabb megközelítés, ha csak akkor használja az ingatlant, amikor szüksége van rá:

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

Használja okosan a környezeti változókat és a globális változókat. Ha egy változó hatóköre túlmutat egyetlen képernyőn, használjon globális változókat a környezeti változók helyett.

A túl sok nem használt változó növeli a memóriahasználatot, és lelassíthatja az alkalmazások inicializálását. Az erőforrások akkor is le vannak foglalva ezekhez a változókhoz, ha nem használja őket. A nem használt változók is összetettebbé teszik az alkalmazás logikáját. A jobb teljesítmény és a könnyebb fejlesztés érdekében tartsa tisztán és rendezetten a Power Appot.

Gyűjtemények optimalizálása

A gyűjtemények olyan ideiglenes adattárolási struktúrák, amelyeket az adatok Power Apps-alkalmazásban való tárolására és kezelésére használnak. A gyűjtemények azonban teljesítménybeli többletterhelést okozhatnak. Korlátozza a gyűjtemények használatát, és csak szükség esetén használja őket.

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

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

A helyi gyűjtemény rekordjainak megszámlálásához használja CountIf a helyett Count(Filter()).

A gyűjtemények használatakor vegye figyelembe ezt a megközelítést:

  • Korlátozza a gyűjtemények méretét és számát. Mivel a gyűjtemények az alkalmazáson belül vannak, a mobileszköz memóriájában vannak tárolva. Minél több adatgyűjteményt tartalmaz, vagy minél több gyűjteményt használ, annál rosszabb a teljesítmény. Használja a ShowColumns függvényt, hogy csak bizonyos oszlopokat szerezzen meg. Adja hozzá a függvényt, Filter hogy csak releváns adatokat kapjon.

    A következő példafüggvény a teljes adatkészletet adja vissza:

    ClearCollect(colDemoAccount, Accounts);

    Hasonlítsa össze ezt a függvényt a következő kóddal, amely csak meghatározott rekordokat és oszlopokat ad vissza:

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

    Ez a példa a következő adatkészletet adja vissza:

    Képernyőkép egy colAcc nevű tábláról és két oszlopról, address1_city és névről.

  • Állítsa be az adatforrás frissítési gyakoriságát. Ha új rekordokat vesz fel a gyűjteménybe, frissítse a gyűjteményt, vagy végezzen lekérdezést az új vagy módosított rekordok eléréséhez. Ha több felhasználó frissíti az adatforrást, frissítse a gyűjteményt az új vagy módosított rekordok beszerzéséhez. A több frissítési hívás több interakciót jelent a kiszolgálóval.

Adatok gyorsítótárazása gyűjteményekben és változókban

A gyűjtemény olyan táblaváltozó, amely adatsorokat és -oszlopokat tárol, nem csak egyetlen adatelemet. A gyűjtemények két fő okból hasznosak: az adatok összesítése az adatforrásba való küldés előtt, valamint az információk gyorsítótárazása a gyakori lekérdezések elkerülése érdekében. Mivel a gyűjtemények megfelelnek az adatforrás táblázatos szerkezetének és a Power Apps rendszerének, hatékonyan kezelheti az adatokat, még offline állapotban is.

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

A nem használt változók és adathordozók eltávolítása

Bár a nem használt adathordozók és változók nem feltétlenül befolyásolják jelentősen az alkalmazás teljesítményét, fontos, hogy a nem használt adathordozók vagy változók eltávolításával törölje az alkalmazást.

  • A nem használt médiafájlok növelik az alkalmazás méretét, ami lelassíthatja az alkalmazások betöltési idejét.

  • A nem használt változók növelik a memóriahasználatot, és kissé lelassíthatják az alkalmazások inicializálását. Az erőforrások akkor is le vannak foglalva ezekhez a változókhoz, ha nincsenek használatban. A túl sok nem használt változó összetettebbé teheti az alkalmazás logikáját.

  • Az Alkalmazásellenőrző segítségével áttekintheti a nem használt médiafájlokat és változókat.

Képernyők és vezérlők optimalizálása

A Power Apps képernyőinek és vezérlőinek optimalizálásához vegye figyelembe az alábbi ajánlott eljárásokat.

Kerülje a vezérlők közötti kereszthivatkozásokat

A más képernyőkön lévő vezérlőkre hivatkozó vezérlők lelassíthatják az alkalmazások betöltését és navigációját. Ez a módszer kényszerítheti az alkalmazást a többi képernyő betöltésére ahelyett, hogy megvárja, amíg a felhasználó a képernyőre kerül. A probléma megoldásához használjon változókat, gyűjteményeket és navigációs környezetet az állapot képernyők közötti megosztásához.

A Power Apps Studio alkalmazás-ellenőrzője kereszthivatkozású vezérlőket jelenít meg. A probléma megoldásához rendszeresen tekintse át az alkalmazásellenőrzőt.

Az alábbi képen a Gallery 1 vezérlő a 2. képernyő 2. felirat vezérlőelemében van kereszthivatkozva.

A Power Apps Studio képernyőképe, amely egy kereszthivatkozott vezérlőt mutat.

Ha az alkalmazás első képernyőjének egy vezérlőelemére hivatkozik a második képernyőn, nincs teljesítménycsökkenés, mert az első képernyő már be van töltve. Ez a viselkedés valójában hasznos, mert az alkalmazás deklaratív a változók használata helyett.

Ha olyan vezérlőkre hivatkozik, amelyek még nincsenek betöltve, például a 3. képernyőről elnevezett Label 3 vezérlőelemre hivatkozó első képernyőn, az alkalmazás betölti a képernyőt a memóriába.

A DelayOutput engedélyezése szövegvezérlőkhöz

Ha a DelayOutput beállítás értéke igaz, fél másodperces késés után regisztrálja a felhasználói bemenetet. Ez a késleltetés hasznos lehet a költséges műveletek elhalasztásához, amíg a felhasználó be nem fejezi a szövegbevitelt, például szűrést, amikor más képletekben bemenetet használ.

Vegyük például azt a gyűjteményt, amelynek Elemei szűrése attól függően történik, hogy a felhasználó mit ír be a TextInput vezérlőbe:

  • Ha a DelayOutput hamisra állítja, ami az alapértelmezett, a galéria azonnal szűr, amint elkezd beírni bármilyen szöveget. Ha sok elemet tartalmazó katalógussal rendelkezik, a katalógus újrabetöltése a módosításokkal azonnal lelassítja a teljesítményt. Jobb várni. Ez a viselkedés akkor hasznos, ha a TextInput karakterláncot keresési sztringként vagy a StartsWith függvényt használja.

  • Ha a DelayOutput értéket igazra állítja, a módosítások észlelése előtt automatikusan egy rövid késleltetés következik. Ez a késés időt biztosít a gépelés befejezésére. A késés jól működik a TextInput.OnChange tulajdonsággal. Ha a műveletek a módosításokhoz vannak kötve, nem szeretné aktiválni őket, amíg be nem fejezi a beírást a mezőbe.

Delegálás és kiszolgálóoldali feldolgozás

A delegálás és a kiszolgálóoldali feldolgozás lehetővé teszi, hogy az alkalmazás hatékonyan kezelje a nagyméretű adathalmazokat a műveletek adatforrásba való kiszervezésével.

Delegálás

A Power Apps esetében a delegálás azt jelenti, hogy az alkalmazás képes bizonyos műveleteket kiszervezni az alapul szolgáló adatforrásra, ahelyett, hogy a műveleteket Power Apps-en belül dolgozza fel. A delegálás Power Apps használatával hatékonyabb és méretezhetőbb alkalmazásokat hozhat létre, amelyek nagy adathalmazokat érintő forgatókönyvekben is jól teljesítenek. Vegye figyelembe az egyes adatforrások és műveletek delegálási korlátozásait, és ennek megfelelően tervezheti meg az alkalmazást az optimális teljesítmény elérése érdekében.

Megjegyzés

Nem minden függvény delegálható. További információ a delegálásról a lekérdezési korlátozásokban: Delegálás és lekérdezési korlátok.

A delegálásnak számos előnye van, például a lekérdezésoptimalizálás és a nagy adathalmazok támogatása. Ezenkívül, ha a forrásadatok gyakran változnak, a delegálás segít naprakészen tartani az adatokat.

Az adatforrásra irányuló API-hívások csökkentése

Néha kényelmesnek tűnhet gyűjtemények létrehozása a vászonalapú alkalmazáson belüli illesztések végrehajtásával. Vegye figyelembe az alábbi példát. A példában két tábla található: Sofőrök és Teherautók. A kód létrehozza a járművezetők és a teherautó adatainak gyűjteményét, és minden teherautóhoz felhívja a teherautó tulajdonosát.

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

Az ilyen illesztés a vászonalapú alkalmazásban számos hívást generálhat az adatforráshoz, ami lassú betöltési időt eredményez.

Jobb megközelítés:

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

A valós idejű forgatókönyvben öt percről 10 másodperc alá csökkentheti a betöltési időt a forrásban lévő adatok javításával.

Kiszolgálóoldali feldolgozás

Különböző adatforrások, például az SQL és Dataverse lehetővé teszik az adatfeldolgozás, például a szűrők és a keresések delegálását az adatforráshoz. A SQL Server lekérdezéssel definiált nézeteket hozhat létre. A Dataverse-ben kevés kódot igénylő beépülő modulokat hozhat létre a kiszolgálón lévő adatok feldolgozásához, és csak a végső eredményeket adhatja vissza a vászon alkalmazásának.

Az adatfeldolgozás kiszolgálóra való delegálása javíthatja a teljesítményt, csökkentheti az ügyféloldali kódot, és megkönnyítheti az alkalmazás karbantartását.

Tudjon meg többet a beépülő modulokról a Dataverse-ben.

Lekérdezési adatminták optimalizálása

Az alkalmazás lekérdezési adatainak optimalizálása jelentősen csökkentheti a betöltési időt, és javíthatja az általános válaszkészséget.

Használjon explicit oszlopkijelölést

Az Explicit oszlopkijelölés (ECS) funkció alapértelmezés szerint be van kapcsolva minden új alkalmazáshoz. Ha nincs bekapcsolva az Ön alkalmazásához, kapcsolja be. Az ECS automatikusan csökkenti a beolvasott oszlopok számát csak az alkalmazásban használtakra. Ha az ECS nincs bekapcsolva, előfordulhat, hogy a szükségesnél több adatot kap, ami befolyásolhatja a teljesítményt. Néha, amikor egy alkalmazás gyűjteményeken keresztül kap adatokat, az oszlop eredeti forrása elveszhet. Az ECS elveti az oszlopokat, ha nem tudja megállapítani, hogy használatban vannak-e. Ha az ECS-t egy hiányzó oszlop megtartására szeretné kényszeríteni, használja a Power Fx kifejezést ShowColumns egy gyűjteményhivatkozás vagy egy vezérlő után.

Gyűjtemény feltöltéséhez ne hívja meg a Power Automate

A gyakori gyakorlat az, hogy a Power Automate használatával olvasunk be és töltsünk fel gyűjteményeket a Power Appsban. Bár ez a megközelítés érvényes, vannak olyan helyzetek, amikor nem biztos, hogy ez a leghatékonyabb választás. A Power Automate hívása hálózati késleltetést okoz, és 0,6 másodperces teljesítménycsökkenést eredményez a Power Automate folyamat példányosításakor.

A Power Automate folyamatok túlhasználata végrehajtási korlátokhoz és szabályozáshoz is vezethet. Mindig értékelje ki a hálózati késés és a teljesítményköltség közötti kompromisszumot.

Szüntesse meg az N+1 problémát

Az N+1 probléma gyakori probléma az adatbázis-lekérdezésekben, ahol ahelyett, hogy egyetlen lekérdezésben lekérnék az összes szükséges adatot, több további lekérdezést végeznek a kapcsolódó adatok lekéréséhez. Ez a probléma teljesítményproblémákhoz vezethet, mivel minden további lekérdezés többletterheléssel jár.

Egy ilyen egyszerű hívás, amely betölt egy gyűjteményt, N+1-hívásokat generálhat az adatforrásba:

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

A vászonalapú alkalmazások és gyűjtemények kontextusában az N+1 probléma a kapcsolódó rekordokat megjelenítő adatforrásokkal és gyűjteményekkel való munka során merülhet fel. A probléma általában akkor fordul elő, ha a galériában megjelenített egyes elemekhez több lekérdezés történik, ami teljesítményproblémához vezet.

A SQL Server objektumainak megtekintése használatával elkerülheti az N+1 lekérdezési problémát, vagy módosíthatja a felhasználói felületet az N+1 forgatókönyv aktiválásának elkerülése érdekében.

Dataverse automatikusan lekéri a kapcsolódó táblák szükséges adatait, és kiválaszthatja az oszlopokat a kapcsolódó táblákból.

ThisItem.Account.'Account Name'

Ha a RelatedDataSource méret kicsi (kevesebb mint 500 rekord), tárolja egy gyűjteményben, és használja a gyűjteményt az (N+1) keresési lekérdezések végrehajtásához.

A csomag méretének korlátozása

Bár Power Apps optimalizálja az alkalmazások betöltését, lépéseket tehet az alkalmazások lábnyomának csökkentése érdekében. A kisebb lábnyom különösen fontos a régebbi eszközök felhasználói vagy a helyi felhasználók számára, ahol nagyobb a késés vagy csökken a sávszélesség.

  • Értékelje ki az alkalmazásba beágyazott médiatartalmat. Ha valamit nem használ, törölje azt.

    Előfordulhat például, hogy a beágyazott képek túl nagyok. PNG-fájlok helyett ellenőrizze, hogy használhat-e SVG-képeket. Ügyeljen arra, hogy SVG-képekben szöveget használjon, mert a betűtípust telepíteni kell az ügyfélre. Követhető megoldás, ha szöveget kell megjelenítenie, hogy egy szövegfeliratot helyez el egy kép fölé.

  • Értékelje ki, hogy a felbontás megfelelő-e a formátumhoz. A mobilalkalmazások felbontásának nem kell olyan magasnak lennie, mint az asztali alkalmazások felbontásának. Kísérletezzen a képminőség és a méret megfelelő egyensúlyának eléréséhez.

  • Ha nem használt képernyői vannak, törölje őket. Ügyeljen arra, hogy ne törölje azokat a rejtett képernyőket, amelyeket csak az alkalmazáskészítők vagy a rendszergazdák használnak.

  • Értékelje ki, hogy túl sok munkafolyamatot próbál-e elhelyezni egy alkalmazásban. Például ugyanabban az alkalmazásban rendszergazdai és ügyfélképernyők is vannak? Ha igen, fontolja meg az egyes alkalmazásokra bontásukat. Ez a megközelítés azt is megkönnyíti, hogy egyszerre többen dolgozhassanak az alkalmazásokon, és korlátozza a "robbanási sugarat" (a tesztelés mennyiségét), amikor az alkalmazásmódosítások teljes tesztidőt igényelnek.

ForAll optimalizálása

A Power Apps ForAll függvénye egy rekordtáblán keresztüli iterálásra szolgál, és képleteket vagy képletkészleteket alkalmaz minden rekordra. Bár maga a függvény sokoldalú, a ForAll függvény nem megfelelő használata miatt az alkalmazás gyorsan kevésbé teljesíthető.

A ForAll függvény egyedüli szekvenciális függvény egy konkurens függvény helyett. Ezért egyszerre csak egy rekordot néz meg, megkapja az eredményt, majd a következő rekordot folytatja, amíg a hatókörében lévő összes rekordon át nem megy.

Kerülje a ForAll beágyazását. Ez a gyakorlat exponenciális iterációkhoz vezethet, és jelentősen befolyásolhatja a teljesítményt.

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

A Batch frissíti az adatbázist

Használhatja a ForAll és Patch eszközöket az adatbázis kötegelt frissítésére. Azonban legyen óvatos, amikor a ForAll és Patch sorrendjét használja.

A következő függvény a jobb megközelítés, például:

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

Mivel a következő megközelítés kevésbé hatékony:

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

Következő lépés

Hibakezelés

  • Last updated on