Vytvářejte velké a složité aplikace plátna

Většina článků v této části dokumentace se týká výkonu aplikací za běhu, jak ho vnímají lidé, kteří je používají. Tento článek popisuje výkon aplikací, jak ho zažívají lidé, kteří je vytvářejí.

Jak se aplikace zvětšují a zesložiťují, Power Apps Studio musí načítat a spravovat velké množství ovládacích prvků, vzorců a zdrojů dat se vzájemnými závislostmi, které exponenciálně rostou. Doba načítání aplikace pro Power Apps Studio se může zpomalit a funkce, jako je IntelliSense a barevné kódování, mohou mít prodlevu. Následující doporučení zlepší vaši práci s velkými a složitými aplikacemi v Power Apps Studio. Mohou také pomoci zlepšit výkon vašich aplikací za běhu.

Příklady v tomto tématu využívají vzorové řešení Reakce nemocnice na nouzové situace.

Použití App.Formulas místo App.OnStart

Tip

Jako alternativu k pojmenovaným vzorcům můžete použít funkci With a vlastní výstupní vlastnosti komponenty plátna.

Nejlepší způsob, jak zkrátit dobu načítání aplikace Power Apps Studio o vaší aplikace, je nahradit inicializaci proměnných a kolekce v App.OnStart za pojmenované vzorce v App.Formulas.

Podívejte se na následující příklad, který využívá 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
    );
);

Protože jde o posloupnost příkazů, aplikace musí vyhodnotit tato volání Set a Collection v pořadí před zobrazením první obrazovky, což zpomaluje načítání aplikace. A protože celá vlastnost App.OnStart musí být zpracována jako celek, musí být zachováno pořadí a chyby nashromážděny před vrácením konečného výsledku, je analýza vzorce pro Power Apps Studio složitá.

Existuje lepší způsob. Použijte App.Formulas namísto toho a definujte tyto proměnné a kolekce jako pojmenované vzorce jako v následujícím příkladu.

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

Tato změna se může zdát malá, ale může mít obrovský dopad. Protože každý pojmenovaný vzorec je nezávislý na ostatních, Power Apps Studio je může analyzovat nezávisle a efektivně rozdělit velké množství App.OnStart na menší kousky. Pozorovali jsme, že jen touto změnou se doba načítání Power Apps Studio sníží až o 80 %.

Vaše aplikace se také načítá rychleji, protože nemusí tyto vzorce vyhodnocovat, dokud nebude potřebovat výsledek. První obrazovka aplikace se zobrazí okamžitě.

Pojmenované vzorce nelze použít ve všech situacích, protože je nelze upravit ani použít s možností Set. Některé situace vyžadují použití stavové proměnné, kterou lze upravit. Set je pro tyto situace ideální a měli byste ji nadále používat. Častěji však používáte globální proměnné v OnStart k nastavení statických hodnot, které se nemění. V těchto případech je pojmenovaný vzorec lepší volbou.

Protože pojmenované vzorce jsou neměnné, předpona var (zkratka pro „proměnná“) jako konvence pojmenování již není vhodná. Názvy v tomto příkladu jsme nezměnili, protože by to vyžadovalo změny ve zbytku aplikace, aby odpovídaly.

Je lákavé umístit pojmenovaný vzorec do App.OnStart, ale nedělejte to. Nepatří tam. Jako vlastnost chování On vyhodnocuje App.OnStart každý ze svých příkazů v pořadí, vytváří globální proměnné a mluví s databázemi pouze jednou při načtení aplikace. Pojmenované vzorce definují, jak něco vypočítat kdykoli je to potřeba a jsou vždy pravdivé. Právě tato povaha vzorců jim umožňuje být nezávislými a umožňuje dokončit načítání aplikace před jejich vyhodnocením.

Rozdělení dlouhých vzorců

App.OnStart je jedním z nejhorších pachatelů dlouhých vzorců a rozhodně byste měli začít zde, ale to není jediný případ.

Naše studie ukázaly, že téměř všechny aplikace s dlouhou dobou načtení aplikací pro Power Apps Studio mají alespoň jeden vzorec delší než 256 000 znaků. Některé aplikace s nejdelší dobou načtení mají vzorce s více než 1 milionem znaků. Formule, které dlouhodobě výrazně zatěžují Power Apps Studio.

Aby toho nebylo málo, kopírování a vkládání ovládacího prvku s dlouhým vzorcem tento vzorech ve vlastnostech ovládacího prvku, aniž by to bylo reflektováno. Power Apps je modelován podle Excelu, kde je běžné více kopií vzorce. V Excelu jsou však vzorce omezeny na jeden výraz a jsou omezeny na 8000 znaků. Vzorce Power Apps mohou narůstat mnohem více díky zavedení imperativní logiky a operátoru řetězení (; nebo ;; v závislosti na národním prostředí).

Obecným řešením je rozdělit dlouhé vzorce na menší části a tyto části znovu použít, jak jsme to udělali v předchozí části, když jsme změnili příkazy Set/Collect v App.OnStart na pojmenované vzorce v App.Formulas. V jiných programovacích jazycích jsou opakovaně využitelné části často označovány jako podprogramy nebo uživatelem definované funkce. Pojmenované vzorce si lze představit jako jednoduchou formu uživatelsky definovaných funkcí bez parametrů a bez vedlejších efektů.

Všude používejte pojmenované vzorce

V předchozím příkladu jsme použili pojmenované vzorce jako náhradu za App.OnStart. Můžete je však použít k nahrazení výpočtu kdekoli v aplikaci.

Například jedna z obrazovek ve vzorovém řešení nouzové reakce nemocnice obsahuje tuto logiku 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
    }
); 

Tento vzorec lze rozdělit na sadu pojmenovaných vzorců. Také to usnadňuje čtení vzorce.

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

Extrahovali jsme ParamFacility jako pojmenovaný vzorec dříve, když jsme přesunuli většinu volání Set z App.OnStart do pojmenovaných vzorců v App.Formulas.

Pojmenované vzorce se vyhodnocují pouze v případě, že jsou potřeba jejich hodnoty. Pokud byl původní úmysl použití Screen.OnVisible odložit práci, dokud se nezobrazí obrazovka, pak bude práce stejně tak odložena jako globální pojmenované vzorce v App.Formulas.

Použití funkce With

K rozdělení logiky můžete ve vzorci také použít funkci With. Vytvořte záznam v prvním parametru s hodnotami, které chcete použít jako pole, a pak použít tato pole ve druhém parametru k výpočtu návratové hodnoty z funkce With. Například předchozí příklad lze zapsat pouze jako jeden pojmenovaný vzorec:

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

Jednou nevýhodou je takového použití vzorce With je, že MyFacility nemůže použít MyRegion, protože jsou definovány ve stejné funkci With, což je problém, který s pojmenovanými vzorci neexistuje. Jedním z řešení je vnořit funkce With a pomocí klíčového slova As pojmenovat záznam pro každou z nich, aby byl snadný přístup ke všem proměnným With.

Použití komponent plátna

Komponenty plátna se nejčastěji používají k vytvoření ovládacího prvku uživatelského rozhraní, který lze umístit na plátno stejně jako ovládací prvek. Lze je také použít bez umístění do uživatelského rozhraní k provádění výpočtů s vlastními výstupními vlastnostmi jako alternativu k pojmenovaným vzorcům. Komponenty plátna lze snadno sdílet mezi aplikacemi pomocí knihoven komponent a na rozdíl od pojmenovaných vzorců jsou plně podporovány. Je však těžší je konfigurovat a používat než pojmenované vzorce.

Rozdělení logiky:

1. V Power Apps Studio přejděte na kartu Komponenty ve Stromovém zobrazení.
2. Vytvoření nové součásti.
3. V podokně Vlastnosti zapněte Rozsah aplikace Access.
4. Přidejte vlastní vlastnost.
5. Nastavte Typ vlastnosti na Výstup a Datový typ pak podle potřeby.
6. Vyberte Vytvořit.
7. Ve výběru vlastností vedle řádku vzorců v horní části obrazovky vyberte novou vlastnost.
8. Napište vzorec pro logiku, kterou chcete rozdělit a znovu použít.

Použití logiky:

1. Přejděte na kartu Obrazovky ve Stromovém zobrazení:
2. V podokně Vložit rozbalte Vlastní a vložte svou komponentu.
3. Chcete-li vypočítat hodnotu s vlastností, použijte ComponentName.PropertyName.

Použití možnosti Vybrat se skrytým ovládacím prvkem pro imperativní logiku

Imperativní logika se používá k úpravě stavu pomocí funkcí Set a Collect, upozornění uživatele pomocí funkce Notify, přechod na jinou obrazovku nebo aplikaci pomocí funkcí Navigate a Launch a zápis hodnot do databáze pomocí funkcí Patch, SubmitForm nebo RemoveIf.

Pojmenované vzorce a vlastní výstupní vlastnosti komponenty plátna nepodporují imperativní logiku. Běžným způsobem rozdělení imperativní logiky je použití vlastnosti OnSelect skrytého ovládacího prvku.

1. Přidejte na obrazovku ovládací prvek Tlačítko.
2. Nastavte vlastnost OnSelect na imperativní logiku, kterou chcete provést.
3. Nastavte vlastnost Visible na hodnotu false, protože uživatel ji nemusí vidět ani s ní pracovat.
4. Zavolejte Select( Button ), když chcete provést imperativní logiku.

Například jedna z obrazovek v našem příkladu má následující vlastnost OnSelect na ovládacím prvku Tlačítko. (Tento jednoduchý příklad je pouze ilustrativní. Normálně byste tuto techniku použili pouze pro delší vzorce.)

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

Chcete-li tuto logiku rozdělit na části, můžeme je umístit na samostatné ovládací prvky Tlačítko a vybrat je (Select) z originálu:

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

Tato technika funguje pouze na stejné obrazovce. Jiné techniky, které jsou o něco složitější, fungují na různých obrazovkách, jako je použití ovládacího prvku Přepínač, nastavení OnCheck na logiku, kterou chcete spustit, a nastavení Výchozí na globální proměnnou a pak přepnutí globální proměnné pomocí Set( global, true ); Set( global, false ) v bodě, kde chcete spustit logiku.

V tomto příkladu již bylo provedeno určité rozdělení logiky. Komentář uvádí, že „Následné akce lze nalézt v OnSuccess“. Tato událost spustí imperativní logiku po úspěšném odeslání záznamu, což je řešení specifické pro funkci SubmitForm.

Rozdělení aplikace

Některé aplikace se rozrostou na tisíce ovládacích prvků a stovky zdrojů dat, což zpomaluje Power Apps Studio. Stejně jako u dlouhých vzorců lze velké aplikace rozdělit do menších sekcí, které společně vytvářejí jedno uživatelské prostředí.

Oddělení aplikací plátna

Jedním z přístupů je implementace sekcí v samostatných aplikacích plátna a použití funkce Spustit k navigaci mezi samostatnými aplikacemi a předání potřebného kontextu.

Tento přístup byl použit ve vzorovém řešení Reakce nemocnice na nouzové situace. Samostatné aplikace spravují každou z hlavních oblastí celkové aplikace. Aplikace sdílejí společnou komponentu ústředny prostřednictvím knihovny komponent, kterou každá aplikace zobrazuje na své úvodní obrazovce:

Když uživatel vybere oblast, komponenta použije metadata ke zjištění, které aplikace jsou dostupné a která aplikace je hostitelem komponenty. Pokud se požadovaná obrazovka nachází v této aplikaci, (tj. proměnná ThisItem.Screen není prázdná), pak provede se volání Navigate. Ale pokud se požadovaná obrazovka nachází v jiné aplikaci (tj. proměnná ThisItem.PowerAppID není prázdná), pak se použije funkce Launch s ID aplikace cíle a kontextem 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
    )
);

Stav v původní aplikaci bude ztracen, když je spuštěna jiná aplikace. Než zavoláte funkci Spustit, nezapomeňte uložit jakýkoli stav. Zapište ho do databáze, zavolejte SaveData nebo předejte stav cílové aplikaci s parametry, které se čtou pomocí funkce Param.

Modelem řízená aplikace s vlastními stránkami

Sekce lze také implementovat jako vlastní stránky. Vlastní stránky fungují jako mini aplikace plátna s kontejnerem modelem řízených aplikací pro navigaci.

Poznámka

Můžete nám sdělit, jaké máte jazykové preference pro dokumentaci? Zúčastněte se krátkého průzkumu. (upozorňujeme, že tento průzkum je v angličtině)

Průzkum bude trvat asi sedm minut. Nejsou shromažďovány žádné osobní údaje (prohlášení o zásadách ochrany osobních údajů).