Deli z drugimi prek


Zgradite velike in zapletene aplikacije za platno

Večina člankov v tem razdelku dokumentacije obravnava delovanje aplikacij med izvajanjem, kot jih doživljajo ljudje, ki jih uporabljajo. Ta članek obravnava delovanje aplikacij po izkušnjah ljudi, ki jih izdelujejo.

Ker postajajo aplikacije večje in kompleksnejše, Power Apps Studio je treba naložiti in upravljati večje število kontrolnikov, formul in podatkovnih virov, vse z medsebojnimi odvisnostmi, ki eksponentno rastejo. Power Apps Studio nalaganje lahko traja dlje, funkcije, kot sta IntelliSense in barvno kodiranje, pa lahko zaostajajo. Za boljše delo z velikimi in zapletenimi aplikacijami uporabite naslednja priporočila Power Apps Studio. Prav tako lahko pomagajo izboljšati zmogljivost izvajanja vaših aplikacij.

Primeri v tem članku uporabljajo vzorčno rešitev Hospital Emergency odgovor.

Uporabite App.Formulas namesto App.OnStart

Nasvet

Kot alternativo poimenovanim formulam lahko uporabite funkcijo With funkcijo in izhodne lastnosti po meri komponente platna.

Najboljši način za zmanjšanje časa nalaganja tako za Power Apps Studio in za vašo aplikacijo je zamenjava inicializacije spremenljivke in zbirke v App.OnStart z poimenovane formule v App.Formulas.

Poglejmo si naslednji primer, ki uporablja 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
    );
);

Ker gre za zaporedje izjav, mora vaša aplikacija te klice Set in Collect vrednotiti po vrstnem redu, preden lahko prikaže prvi zaslon, zaradi česar se aplikacija nalaga počasneje. In ker je treba celotno App.OnStart obravnavati kot celoto, ohraniti vrstni red in združiti napake, preden se vrne končni rezultat, je formula zapletena za Power Apps Studio analizirati.

Obstaja boljši način. Namesto tega uporabite App.Formulas in te spremenljivke in zbirke definirajte kot poimenovane formule, kot v naslednjem primeru.

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

Ta sprememba se morda zdi majhna, vendar ima lahko velik vpliv. Ker je vsaka imenovana formula neodvisna od drugih, jih Power Apps Studio lahko analizira neodvisno in učinkovito razdeli veliko App.OnStart na manjše dele. Samo s to spremembo smo Power Apps Studio čas nalaganja zmanjšali za kar 80 %.

Vaša aplikacija se tudi hitreje naloži, ker ji ni treba ovrednotiti teh formul, dokler ne potrebuje rezultata. Takoj se prikaže prvi zaslon aplikacije.

Poimenovanih formul ni mogoče uporabiti v vseh situacijah, ker jih ne morete spreminjati ali uporabljati z Set. Nekatere situacije zahtevajo uporabo spremenljivke stanja, ki jo je mogoče spremeniti. Set je kot nalašč za te situacije in bi ga morali uporabljati še naprej. Toda pogosteje kot ne uporabljate globalne spremenljivke v OnStart za nastavitev statičnih vrednosti, ki se ne spreminjajo. V teh primerih je imenovana formula boljša izbira.

Ker so poimenovane formule nespremenljive, predpona var (okrajšava za "spremenljivka") kot dogovor o poimenovanju ni več ustrezna. Imen v tem primeru nismo spremenili, ker bi bilo treba spremeniti preostali del aplikacije, da bi se ujemala.

Mamljivo je postaviti imenovano formulo v App.OnStart, vendar tega ne storite. Ne sodijo tja. Kot lastnost vedenja On App.OnStart vrednoti vsako svojo izjavo po vrstnem redu, ustvarja globalne spremenljivke in pogovor z bazami podatkov samo enkrat, ko je aplikacija naložena. Poimenovane formule so formule, ki določajo, kako nekaj izračunati kadar koli je to potrebno in so vedno pravilne. Ta narava formule jim omogoča, da so neodvisni in omogoča, da se aplikacija konča z nalaganjem, preden so ocenjeni.

Razdeli dolge formule

App.OnStart je eden najhujših kršiteljev pri dolgih formulah in zagotovo tam, kjer bi morali začeti, vendar to ni edini primer.

Naše študije so pokazale, da imajo skoraj vse aplikacije z dolgim ​​časom nalaganja za Power Apps Studio vsaj eno formulo z več kot 256.000 znaki. Nekatere aplikacije z najdaljšim časom nalaganja imajo formule z več kot milijonom znakov. Formule, ki dolgotrajno močno obremenjujejo Power Apps Studio.

Da bi bile stvari še hujše, kopiranje in lepljenje kontrolnika z dolgo formulo podvoji formulo v lastnostih kontrolnika, ne da bi bila realizirana. Power Apps se zgleduje po Excelu, kjer je pogosto več kopij formule. Vendar pa so v Excelu formule omejene na en izraz in so omejene na 8000 znakov. Power Apps formule se lahko z uvedbo imperativne logike in operatorja veriženja (; ali ;;, odvisno od lokalne nastavitve, precej podaljšajo).

Splošna rešitev je, da dolge formule razdelimo na manjše dele in jih ponovno uporabimo, kot smo storili v prejšnjem razdelku, ko smo spremenili stavke Set/Collect v App.OnStart do imenovanih formul v App.Formulas. V drugih programskih jezikih se deli za večkratno uporabo pogosto imenujejo podprogrami ali uporabniško definirane funkcije. Poimenovane formule si lahko predstavljate kot preprosto obliko uporabniško definirane funkcije brez parametrov ali stranskih učinkov.

Povsod uporabljajte poimenovane formule

V prejšnjem primeru smo uporabili imenovane formule kot zamenjavo za App.OnStart. Vendar pa jih lahko uporabite za zamenjavo izračuna kjer koli v aplikaciji.

Na primer, eden od zaslonov v vzorčni rešitvi za nujne primere v bolnišnici odgovor vključuje to logiko v 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
    }
); 

To formulo je mogoče razdeliti na niz poimenovanih formul. Prav tako olajša branje formule.

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

Izvlekli smo ParamFacility kot imenovano formulo prej, ko smo premaknili večino klicev Set iz App.OnStart na imenovane formule v App.Formulas.

Poimenovane formule se ovrednotijo ​​le, ko so potrebne njihove vrednosti. Če je bil prvotni namen uporabe Screen.OnVisible odložiti delo, dokler ni prikazan zaslon, je delo še vedno odloženo kot globalne poimenovane formule v App.Formulas.

Uporabite funkcijo With

Uporabite lahko tudi funkcijo With v formuli za razdelitev logike. V prvem parametru ustvarite zapis z vrednostmi, ki jih želite uporabiti kot polja, nato pa uporabite ta polja v drugem parametru za izračun povratne vrednosti iz With. Na primer, prejšnji primer lahko zapišemo kot samo eno poimenovano formulo:

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

Slaba stran uporabe With na ta način je, da MyFacility ni mogoče uporabiti MyRegion ker sta definirana v istem S funkcijo, težava, ki ni prisotna pri imenovanih formulah. Ena od rešitev je ugnezditi funkcije With in uporabiti ključno besedo As za poimenovanje zapisa za vsako, da omogočite preprost dostop vsem spremenljivkam With .

Uporabite komponente platna

Komponente platna se najpogosteje uporabljajo za ustvarjanje kontrolnika uporabniškega vmesnika, ki ga je mogoče postaviti na platno tako kot kontrolnik. Uporabite jih lahko tudi, ne da bi jih postavili v uporabniški vmesnik, za izvajanje izračunov z izhodnimi lastnostmi po meri kot alternativo poimenovanim formulam. Komponente platna je enostavno dati v skupno rabo med aplikacijami s knjižnicami komponent in so za razliko od poimenovanih formul v celoti podprte. Vendar jih je težje konfigurirati in uporabljati kot poimenovane formule.

Za razdelitev logike:

  1. V Power Apps Studio preklopite na zavihek Komponente v Drevesnem pogledu.
  2. Ustvarjanje nove komponente.
  3. V podoknu Lastnosti vklopite Obseg aplikacije za dostop.
  4. Dodajte lastnost po meri.
  5. Nastavite Property type na Output in Data type kot je primerno.
  6. izberite Ustvari.
  7. V izbirniku lastnosti poleg vrstice s formulami na vrhu zaslona izberite novo lastnost.
  8. Napišite formulo za logiko za razdelitev in ponovno uporabo.

Če uporabimo logiko:

  1. Preklopite na zavihek Zasloni v Drevesnem pogledu.
  2. V podoknu Vstavi razširite Po meri in vstavite svojo komponento.
  3. Če želite izračunati vrednost z lastnostjo, uporabite ComponentName.PropertyName.

Uporabite Izberi s skritim kontrolnikom za nujno logiko

Imperativna logika se uporablja za spreminjanje stanja z Set in Collect, obveščanje uporabnika z Obvesti, pojdite na drug zaslon ali aplikacijo z Navigate in Launch in zapišite vrednosti v zbirko podatkov s Patch, SubmitForm ali RemoveIf.

Poimenovane formule in izhodne lastnosti po meri komponente platna ne podpirajo imperativne logike. Pogost način za razdelitev imperativne logike je uporaba lastnosti OnSelect skritega kontrolnika.

  1. Na zaslon dodajte kontrolnik Button .
  2. Nastavite lastnost OnSelect na imperativno logiko, ki jo želite izvesti.
  3. Nastavite lastnost Visible na false, saj ni potrebe, da bi jo uporabnik videl ali z njo sodeloval.
  4. Pokličite Select( Button ) ko želite izvesti imperativno logiko.

Eden od zaslonov v našem vzorcu ima na primer naslednjo lastnost OnSelect na kontrolniku Button . (Ta preprost primer je samo za ilustracijo. Običajno bi to tehniko uporabili samo za daljše formule.)

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

Če želite to logiko razdeliti na dele, lahko dele postavimo na ločene Kontrolne gumbe in jih Izberemo iz izvirnika:

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

Ta tehnika deluje samo na istem zaslonu. Druge tehnike, ki so nekoliko bolj zapletene, delujejo na različnih zaslonih, kot je uporaba preklopnega kontrola, nastavitev OnCheck logike želite zagnati, in nastavite Privzeto na globalno spremenljivko in nato preklopite globalno spremenljivko z Set( global, true ); Set( global, false ) na točki, kjer želite zagnati logiko.

V tem primeru je bilo že opravljeno nekaj logičnega ločevanja. Komentar omenja, da je "Naknadna dejanja mogoče najti v OnSuccess." Ta dogodek zažene imperativno logiko, potem ko je bil zapis uspešno oddan, kar je rešitev, specifična za funkcijo SubmitForm .

Razdelite aplikacijo

Nekatere aplikacije se povečajo na tisoče kontrolnikov in stotine virov podatkov, kar upočasni Power Apps Studio. Tako kot pri dolgih formulah je mogoče velike aplikacije razdeliti na manjše dele, ki skupaj ustvarjajo eno uporabniško izkušnjo.

Ločene aplikacije za platno

Eden od pristopov je implementacija odsekov v ločenih aplikacijah platna in uporaba funkcije Launch za krmarjenje med ločenimi aplikacijami in posredovanje potrebnega konteksta.

Ta pristop je bil uporabljen v vzorčni rešitvi Hospital Emergency odgovor. Ločene aplikacije upravljajo vsako od glavnih področij celotne aplikacije. Aplikacije imajo skupno komponento stikalne plošče prek knjižnica komponent, ki jo vsaka aplikacija prikaže na svojem zagonskem zaslonu:

Posnetek zaslona bolnišnične nujne pomoči odgovor Vzorčna aplikacija platna rešitve, ki se izvaja v telefonu, prikazuje komponento platna centrale.

Ko uporabnik izbere območje, komponenta uporabi metapodatke o aplikacijah, ki so na voljo, in o tem, katera aplikacija gosti komponento. Če je želeni zaslon v tej aplikaciji (to je ThisItem.Screen ni prazen), potem a Navigate klic je opravljen. Če pa je želeni zaslon v drugi aplikaciji (to je ThisItem.PowerAppID ni prazen), potem Zaženi funkcija se uporablja z ID-jem aplikacije cilja in kontekstom FacilityID:

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

Stanje v izvirni aplikaciji se izgubi, ko se zažene druga aplikacija. Ne pozabite shraniti katerega koli stanja, preden pokličete funkcijo Zaženi . Zapišite ga v zbirko podatkov, pokličite SaveData ali posredujte stanje ciljni aplikaciji s parametri, ki se preberejo s Param funkcija.

Aplikacija, ki temelji na modelu, s stranmi po meri

Razdelke je mogoče implementirati tudi kot strani po meri. Strani po meri delujejo kot mini aplikacija na platnu z vsebnikom aplikacij, ki temelji na modelu, za navigacijo.

Opomba

Ali nam lahko poveste, kateri je vaš prednostni jezik za dokumentacijo? Izpolnite kratko anketo. (upoštevajte, da je v angleščini)

Z anketo boste porabili približno sedem minut. Ne zbiramo nobenih osebnih podatkov (izjava o zasebnosti).