Kurkite dideles ir sudėtingas drobės programas

Straipsnis
01/30/2024

Dauguma šio dokumentacijos skyriaus straipsnių apima programų vykdymo laiką, kurį patiria jas naudojantys žmonės. Šiame straipsnyje aprašomas programų našumas, kurį patiria jas kuriantys žmonės.

Kadangi programos tampa didesnės ir sudėtingesnės, reikia įkelti ir valdyti didesnį valdiklių, formulių ir duomenų šaltinių skaičių, o visa tai turi tarpusavio priklausomybę, Power Apps Studio kuri auga eksponentiškai. Power Apps Studio įkėlimas gali užtrukti ilgiau, o tokios funkcijos kaip "IntelliSense" ir spalvų kodavimas gali vėluoti. Naudokite toliau pateiktas rekomendacijas, kad geriau dirbtumėte su didelėmis ir sudėtingomis programomis Power Apps Studio. Jie taip pat gali padėti pagerinti programų vykdymo laiką.

Šiame straipsnyje pateiktuose pavyzdžiuose naudojamas ligoninės reagavimo į ekstremalias situacijas pavyzdinis sprendimas.

Naudokite App.Formulas vietoj App.OnStart

Arbatpinigiai

Kaip alternatyvą įvardytoms formulėms galite naudoti su funkcijų ir drobės komponentų pasirinktines išvesties ypatybes.

Geriausias būdas sutrumpinti abiejų Power Apps Studio programų įkėlimo laiką yra pakeisti kintamojo ir rinkimo inicijavimą App.OnStart pavadintomis formulėmis App.Formulas.

Pažvelkime į šį pavyzdį, kuriame naudojama App.OnStart.

// Get the color of text on a dark background.
Set(varColorOnDark,RGBA(0, 0, 0, 1));

// Get the color of the menu icons.
Set(varColorMenuIcon,"#0070a9");

// Get the styles for a form.
Set(varFormStyle,
    {
        DataCard: { Height: 50 },
        Title: { Height: 50, Size: 21, Color: varColorOnDark },
        Control: { Height: 50, Size: 18 },
        Label: { Size: 18, Color: varColorOnDark }
    }
);

ClearCollect(
    FacilitiesList,
    ForAll(
        Facilities,
        { Name: 'Facility Name', Id: Facility }
    )
);
If(
    Not IsBlank(Param("FacilityID")),
    Set(ParamFacility,
        LookUp(
            FacilitiesList,
            Id = GUID(Param("FacilityID"))
        ).Name
    );
);

Kadangi tai yra teiginių seka, programa turi tvarkingai įvertinti šiuos nustatymus Nustatyti ir Rinkti skambučius, kad galėtų rodyti pirmąjį ekraną, todėl programa įkeliama lėčiau. Ir kadangi visa App.OnStart turi būti vertinama kaip visuma, išsaugota tvarka ir klaidos agreguotos prieš grąžinant galutinį rezultatą, formulę sudėtinga analizuoti Power Apps Studio .

Yra geresnis būdas. Vietoj to naudokite App.Formulas ir apibrėžkite šiuos kintamuosius bei rinkinius kaip pavadintas formules, kaip parodyta toliau pateiktame pavyzdyje.

// Get the color of text on a dark background.
varColorOnDark = RGBA(0, 0, 0, 1);

// Get the color of the menu icons.
varColorMenuIcon = "#0070a9";

// Get the styles for a form.
varFormStyle = 
    {
        DataCard: { Height: 50 },
        Title: { Height: 50, Size: 21, Color: varColorOnDark },
        Control: { Height: 50, Size: 18 },
        Label: { Size: 18, Color: varColorOnDark }
    };

FacilitiesList =
    ForAll(
        Facilities,
        { Name: 'Facility Name', Id: Facility }
    );

ParamFacility = 
    If( Not IsBlank(Param("FacilityID")),
        LookUp(
            FacilitiesList,
            Id = GUID(Param("FacilityID"))
        ).Name,
        Blank()
    );

Šis pokytis gali atrodyti nedidelis, tačiau jis gali turėti didžiulį poveikį. Kadangi kiekviena pavadinta formulė yra nepriklausoma nuo kitų, gali jas analizuoti savarankiškai, Power Apps Studio efektyviai padalindama didelę App.OnStart į mažesnes dalis. Vien dėl šio pakeitimo pastebėjome, kad Power Apps Studio įkėlimo laikas sumažėjo net 80%.

Jūsų programa taip pat įkeliama greičiau, nes jai nereikia vertinti šių formulių, kol jai nereikia rezultato. Pirmasis programos ekranas rodomas iš karto.

Įvardytųjų formulių negalima naudoti visose situacijose, nes negalite jų modifikuoti arba naudoti su rinkiniu. Kai kuriose situacijose reikia naudoti būsenos kintamąjį, kurį galima keisti. Rinkinys puikiai tinka tokioms situacijoms, todėl turėtumėte ir toliau jį naudoti. Tačiau dažniausiai "OnStart" naudojate visuotinius kintamuosius, kad nustatytumėte statines reikšmes, kurios nesikeičia. Tokiais atvejais įvardyta formulė yra geresnis pasirinkimas.

Kadangi įvardytos formulės yra nekintamos, priešdėlis var (trumpinys iš "kintamasis") kaip įvardijimo konvencija nebetinka. Šiame pavyzdyje pavadinimų nekeitėme, nes reikės pakeisti likusią programos dalį, kad ji atitiktų.

Kyla pagunda įdėti pavadintą formulę į App.OnStart, bet ne. Jie ten nepriklauso. Kaip "On behavior" ypatybę, "App.OnStart " įvertina kiekvieną savo teiginį eilės tvarka, kurdama visuotinius kintamuosius ir kalbėdama su duomenų bazėmis tik vieną kartą, kai programa įkeliama. Įvardytos formulės yra formulės, apibrėžiančios, kaip ką nors apskaičiuoti, kai tik reikia, ir visada yra teisingos. Būtent šis formulės pobūdis leidžia jiems būti nepriklausomiems ir leidžia programai baigti įkelti prieš juos įvertinant.

Išskaidykite ilgas formules

"App.OnStart" yra vienas blogiausių ilgų formulių pažeidėjų ir tikrai nuo ko reikėtų pradėti, tačiau tai nėra vienintelis atvejis.

Mūsų tyrimai parodė, kad beveik visos programos, kurių įkėlimo laikas ilgas, Power Apps Studio turi bent vieną formulę, kurią sudaro daugiau nei 256 000 simbolių. Kai kurių programų, kurių įkėlimo laikas yra ilgiausias, formulės yra sudarytos iš daugiau nei 1 milijono simbolių. Formulės, kurios ilgai kelia didelę įtampą Power Apps Studio.

Dar blogiau, nukopijavus ir įklijavus valdiklį su ilga formule, formulė dubliuojama valdiklio ypatybėse jos nerealizuojant. Power Apps modeliuojamas pagal programą Excel, kur įprastos kelios formulės kopijos. Tačiau programoje "Excel" formulės apsiriboja vienu reiškiniu ir yra apribotos iki 8 000 simbolių. Power Apps formulės gali augti daug ilgiau, įvedus imperatyvią logiką ir grandinės operatorių (; arba ;;, priklausomai nuo lokalės).

Bendras sprendimas yra suskaidyti ilgas formules į mažesnes dalis ir pakartotinai naudoti dalis, kaip darėme ankstesniame skyriuje, kai pakeitėme "Set Collect"/sakinius App.OnStart į pavadintas formules App.Formulas ·. Kitose programavimo kalbose daugkartinio naudojimo dalys dažnai vadinamos subroutinais arba vartotojo apibrėžtomis funkcijomis. Galite galvoti apie įvardytas formules kaip apie paprastą vartotojo apibrėžtos funkcijos formą be parametrų ar šalutinio poveikio.

Įvardytųjų formulių naudojimas visur

Ankstesniame pavyzdyje įvardytas formules naudojome kaip App.OnStart pakaitalą. Tačiau galite juos naudoti norėdami pakeisti skaičiavimą bet kurioje programos vietoje.

Pavyzdžiui, viename iš ligoninės skubios pagalbos pavyzdinio sprendimo ekranų yra ši logika Screen.OnVisible:

ClearCollect(
    MySplashSelectionsCollection,
    {
        MySystemCol: First(
            Filter(
                Regions,
                Region = MyParamRegion
            )
        ).System.'System Name',
        MyRegionCol: First(
            Filter(
                Regions,
                Region = MyParamRegion
            )
        ).'Region Name',
        MyFacilityCol: ParamFacility,
          MyFacilityColID:  LookUp(
            FacilitiesList,
            Id = GUID(Param("FacilityID"))
        ).Id
    }
);

Šią formulę galima suskaidyti į įvardytų formulių rinkinį. Tai taip pat palengvina formulės skaitymą.

MyRegion = LookUp(
                    Regions,
                    Region = MyParamRegion
           );

MyFacility = LookUp(
                    FacilitiesList,
                    Id = GUID(Param("FacilityID")
            );

MySplashSelectionsCollection = 
    {
        MySystemCol: MyRegion.System.'System Name',
        MyRegionCol: MyRegion.'Region Name',
        MyFacilityCol: ParamFacility,
        MyFacilityColID:  MyFacility.Id
    };

"ParamFacility" kaip įvardytą formulę ištraukėme anksčiau, kai perkėlėme daugumą rinkinio skambučių iš "App.OnStart" į pavadintas formules " App.Formulas ".

Įvardytos formulės vertinamos tik tada, kai reikia jų reikšmių. Jei pradinis "Screen.OnVisible" naudojimo tikslas buvo atidėti darbą, kol bus parodytas ekranas, tada darbas vis tiek atidedamas kaip visuotinės pavadintos formulės App.Formulas .

Naudokite funkciją Su

Funkciją Su taip pat galite naudoti formulėje, kad suskaidytumėte logiką. Sukurkite pirmojo parametro įrašą su reikšmėmis, kurias norite naudoti kaip laukus, tada naudokite tuos laukus antrajame parametre, kad apskaičiuotumėte grąžinamą reikšmę iš Su. Pavyzdžiui, ankstesnis pavyzdys gali būti parašytas kaip tik viena pavadinta formulė:

MySplashSelectionsCollection = 
    With( { MyRegion: LookUp(
                            Regions,
                            Region = MyParamRegion
                      ),
            MyFacility: LookUp(
                            FacilitiesList,
                            Id = GUID(Param("FacilityID")
                      ) 
           },
           {
                MySystemCol: MyRegion.System.'System Name',
                MyRegionCol: MyRegion.'Region Name',
                MyFacilityCol: ParamFacility,
                MyFacilityColID:  MyFacility.Id
           }
    )

Vienas trūkumas naudojant Naudojant šį būdą yra tai, kad negalima naudoti MyFacility , nes jie apibrėžti toje pačioje MyRegion Su funkcija, problema, kurios nėra įvardytose formulėse. Vienas iš sprendimų yra įdėti Su funkcijomis ir naudoti raktinį žodį Kaip , kad pavadintumėte kiekvieno įrašą, kad galėtumėte lengvai pasiekti visus kintamuosius Su .

Naudokite drobės komponentus

Drobės komponentai dažniausiai naudojami kuriant vartotojo sąsajos valdiklį, kurį galima įdėti į drobę kaip valdiklį. Taip pat galite juos naudoti neįdėdami jų į vartotojo sąsają, kad atliktumėte skaičiavimus su pasirinktinėmis išvesties ypatybėmis kaip alternatyvą įvardytoms formulėms. Drobės komponentus lengva bendrinti programose su komponentų bibliotekomis ir, kitaip nei įvardytas formules, jie visiškai palaikomi. Tačiau jas sunkiau konfigūruoti ir naudoti nei įvardytas formules.

Norėdami suskaidyti logiką:

Į Power Apps Studio, perjunkite į Komponentai skirtuką medžio rodinyje.
Naujo komponento kūrimas.
Srityje Ypatybės įjunkite "Access" taikomosios programos aprėptį.
Įtraukite pasirinktinę ypatybę.
Atitinkamai nustatykite ypatybės tipą į Išvestis ir duomenų tipą .
Pasirinkite Kurti.
Ypatybių parinkiklyje, esančiame šalia formulės juostos ekrano viršuje, pasirinkite naują ypatybę.
Parašykite formulę, kad logika būtų skaidoma ir pakartotinai naudojama.

Norėdami naudoti logiką:

Perjunkite į skirtuką Ekranai medžio rodinyje.
Srityje Įterpimas išplėskite Pasirinktinis ir įterpkite komponentą.
Norėdami apskaičiuoti reikšmę su ypatybe, naudokite ComponentName.PropertyName.

Naudokite "Select" su paslėptu valdikliu, kad nustatytumėte imperatyvią logiką

Imperatyvi logika naudojama norint modifikuoti būseną naudojant "Set and Collect ", pranešti vartotojui "Notify ", pereiti į kitą ekraną ar programą su "Navigate and Launch" ir įrašyti reikšmes į duomenų bazę naudojant "Patch", "SubmitForm" arba " · RemoveIf".

Įvardytos formulės ir drobės komponento pasirinktinės išvesties ypatybės nepalaiko imperatyvios logikos. Įprastas būdas suskaidyti imperatyvią logiką yra naudoti paslėpto valdiklio ypatybę OnSelect .

Mygtuko valdiklio įtraukimas į ekraną.
Nustatykite ypatybę OnSelect į imperatyvią logiką, kurią norite vykdyti.
Nustatykite ypatybę Matomas kaip klaidingą, nes vartotojui nereikia jos matyti ar su ja sąveikauti.
Skambinkite Select( Button ) , kai norite vykdyti imperatyvią logiką.

Pavyzdžiui, viename iš mūsų pavyzdžio ekranų mygtuko valdiklyje yra ši ypatybė OnSelect . (Šis paprastas pavyzdys skirtas tik iliustracijai. Paprastai šią techniką naudotumėte tik ilgesnėms formulėms.)

btnAction_17.OnSelect = 
    Trace("Feedback Screen: Submit Button",TraceSeverity.Information);
    If(
        // Proceed if all forms are validated.
        And(
            FormFeedback.Valid
        ),
    
        // Set the updates to static variables.
        Set(updatesFeedback,Patch(Defaults('App Feedbacks'), FormFeedback.Updates));
        // Submit the first form. Subsequent actions can be found in the OnSuccess.
        SubmitForm(FormFeedback);
        ,
    
        Notify("Please complete all fields before proceeding",
               NotificationType.Warning,2000)
    );

Norėdami padalyti šią logiką į dalis, galime sudėti dalis į atskirus Mygtukų valdiklius ir Pasirinkite juos iš originalo:

btnTrace.OnSelect = 
    Trace("Feedback Screen: Submit Button",TraceSeverity.Information);

btnSubmit.OnSelect = 
    If(
        // Proceed if all forms are validated.
        And(
            FormFeedback.Valid
        ),
    
        // Set the updates to static variables.
        Set(updatesFeedback,Patch(Defaults('App Feedbacks'), FormFeedback.Updates));
        // Submit the first form. Subsequent actions can be found in OnSuccess.
        SubmitForm(FormFeedback);
        ,
    
        Notify("Please complete all fields before proceeding",
               NotificationType.Warning,2000)
    );

btnAction_17.OnSelect = 
    Select( btnTrace );
    Select( btnSubmit );

Ši technika veikia tik tame pačiame ekrane. Kiti šiek tiek sudėtingesni metodai veikia įvairiuose ekranuose, pvz., naudojant perjungimo valdiklį, nustatant OnCheck pagal logiką, kurią norite paleisti, ir nustatant Numatytąjį į visuotinį kintamąjį, tada perjungiant visuotinį kintamąjį tame Set( global, true ); Set( global, false ) taške, kuriame norite paleisti logiką.

Šiame pavyzdyje tam tikras logikos skaidymas jau buvo atliktas. Komentare minima, kad "Tolesnius veiksmus galima rasti OnSuccess". Šis įvykis veikia pagal imperatyvią logiką po to, kai įrašas buvo sėkmingai pateiktas, o tai yra sprendimas, būdingas funkcijai SubmitForm .

Padalinkite programą

Kai kurios programos išauga iki tūkstančių valdiklių ir šimtų duomenų šaltinių, o tai sulėtėja Power Apps Studio. Kaip ir naudojant ilgas formules, dideles programas galima padalyti į mažesnes dalis, kurios veikia kartu, kad sukurtų vieną vartotojo patirtį.

Atskiros drobės programos

Vienas iš būdų yra įdiegti skyrius atskirose drobės programose ir naudoti paleidimo funkciją, kad galėtumėte naršyti tarp atskirų programų ir perduoti reikiamą kontekstą.

Šis metodas buvo naudojamas ligoninės reagavimo į ekstremalias situacijas mėginio sprendime. Atskiros programos valdo kiekvieną iš pagrindinių visos programos sričių. Programos bendrina bendrą skirstomojo skydo komponentą per komponentų biblioteką, kurią kiekviena programa rodo paleisties ekrane:

Ligoninės reagavimo į ekstremalias situacijas pavyzdinės sprendimo drobės programos, veikiančios telefone, ekrano nuotrauka, kurioje rodomas skirstomojo skydo drobės komponentas.

Kai vartotojas pasirenka sritį, komponentas naudoja metaduomenis apie galimas programas ir apie tai, kuri programa priglobia komponentą. Jei šioje programoje yra norimas ekranas (tai yra, ThisItem.Screen nėra tuščias), tada skambinama naršyti . Bet jei norimas ekranas yra kitoje programoje (tai yra, ThisItem.PowerAppID nėra tuščias), tada paleidimo funkcija naudojama su paskirties vietos programos ID ir FacilityID kontekstu:

If(
    IsBlank(ThisItem.Screen),
    If(IsBlank(ThisItem.PowerAppID), 
        Launch(ThisItem.URL),           
        Launch("/providers/Microsoft.PowerApps/apps/" & ThisItem.PowerAppID, 
               "FacilityID", Home_Facility_DD.Selected.Id)
    ),
    Navigate(
        ThisItem.Screen,
        Fade
    )
);

Pradinės programos būsena prarandama, kai paleidžiama kita programa. Būtinai išsaugokite bet kurią būseną prieš skambindami paleidimo funkcijai. Įrašykite jį į duomenų bazę, iškvieskite "SaveData " arba perduokite būseną tikslinei programai su parametrais, kurie skaitomi naudojant "Param " funkciją.

Modeliu pagrįsta programa su tinkintais puslapiais

Sekcijas taip pat galima įdiegti kaip pasirinktinius puslapius. Pasirinktiniai puslapiai veikia kaip mini drobės programa su modeliu pagrįstu programų sudėtiniu rodiniu naršymui.

Pastaba

Ar galite mums pranešti apie dokumentacijos kalbos nuostatas? Atlikite trumpą apklausą. (atkreipkite dėmesį, kad ši apklausa yra anglų kalba)

Apklausą atliksite per maždaug septynias minutes. Asmeniniai duomenys nėra renkami (privatumo nuostatos).

Share via