Delen via

Grote en complexe canvas-apps bouwen

  • Artikel

De meeste artikelen in dit gedeelte van de documentatie behandelen de runtime-prestaties van apps zoals ervaren door de mensen die ze gebruiken. Dit artikel behandelt app-prestaties zoals ervaren door de mensen die ze maken.

Wanneer apps groter en complexer worden, moet Power Apps Studio een groot aantal besturingselementen, formules en gegevensbronnen laden en beheren, met allemaal onderlinge afhankelijkheden die exponentieel groeien. Het kan langer duren om Power Apps Studio te laden, en functies zoals IntelliSense en kleurcodering kunnen vertragen. Gebruik de volgende aanbevelingen om beter met grote en complexe apps te werken in Power Apps Studio. Ze kunnen ook helpen om de runtime-prestaties van uw apps te verbeteren.

De voorbeelden in dit artikel gebruiken de Hospital Emergency Response-voorbeeldoplossing.

App.Formulas gebruiken in plaats van App.OnStart

Tip

U kunt de With-functie en aangepaste uitvoereigenschappen canvascomponent gebruiken als alternatief voor benoemde formules.

De beste manier om de laadtijd voor Power Apps Studio en uw eindgebruikers-app te verlagen is door initialisatie van variabelen en collecties in App.OnStart te vervangen door benoemde formules in App.Formulas.

Laten we naar het volgende voorbeeld kijken, waarin App.OnStart wordt gebruikt.

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

Omdat het een opeenvolging van instructies is, moet uw app deze Set- en Collect-aanroepen op volgorde worden evalueren voordat het eerste scherm kan worden weergeven, waardoor de app langzamer laadt. En omdat de hele App.OnStart ls geheel moet worden beschouwd, de volgorde behouden moet blijven en de fouten moeten worden samengevoegd voordat het uiteindelijke resultaat wordt geretourneerd, is de analyse van de formule voor Power Apps Studio complex.

Er is een betere manier. Gebruik in plaats daarvan App.Formulas en definieer deze variabelen en verzamelingen als benoemde formules, zoals in het volgende voorbeeld.

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

Deze wijziging lijkt misschien klein, maar kan een enorme impact hebben. Omdat elke benoemde formule onafhankelijk is van de andere, kan Power Apps Studio ze onafhankelijk analyseren, waardoor een grote App.OnStart effectief wordt gesplitst in kleinere stukjes. We constateren dat de laadtijd van Power Apps Studio alleen al door deze verandering met maar liefst 80% afneemt.

Uw app laadt ook sneller omdat deze deze formules pas hoeft te evalueren als het resultaat nodig is. Het eerste scherm van de app wordt direct weergegeven.

Benoemde formules kunnen niet in alle situaties worden gebruikt, omdat u ze niet kunt wijzigen of ze met Set kunt gebruiken. Sommige situaties vereisen het gebruik van een statusvariabele die kan worden gewijzigd. Set is perfect voor deze situaties en u wordt aangeraden met het gebruik ervan door te gaan. Maar vaker wel dan niet gebruikt u globale variabelen in OnStart om statische waarden in te stellen die niet veranderen. In die gevallen is een benoemde formule de betere keuze.

Aangezien benoemde formules onveranderlijk zijn, is het voorvoegsel var (afkorting van ´variabele´) als naamgevingsconventie niet langer geschikt. We hebben de namen in dit voorbeeld niet gewijzigd, omdat daarvoor wijzigingen in de rest van de app nodig zijn.

Het is verleidelijk om een benoemde formule in App.OnStart te plaatsen, maar deze hoort daar gewoon niet thuis. Ze horen daar niet. Als een gedragseigenschap On evalueert App.OnStart elk van zijn uitspraken op volgorde, creëert algemene variabelen en praat slechts één keer bij het laden van de app met databases. Benoemde formules zijn formules die bepalen hoe iets moet worden berekend wanneer dat nodig is en zijn deze altijd waar. Vanwege zijn aard kan deze formule onafhankelijk zijn en kan de app het laden voltooien voordat evaluatie plaatsvindt.

Lange formules opsplitsen

App.OnStart is een van de ergste overtreders voor lange formules en zeker de plek om te beginnen, maar het is zeker niet het enige geval.

Onze onderzoeken hebben aangetoond dat bijna alle apps met een lange laattijd voor Power Apps Studio ten minste één formule hebben met meer dan 256.000 tekens. Sommige apps met de langste laadtijden hebben formules van meer dan 1 miljoen tekens. Formules die Power Apps Studio langdurig zwaar belasten.

Om het nog erger te maken, dupliceert het kopiëren en plakken van een besturingselement met een lange formule de formule in de eigenschappen van het besturingselement zonder dat deze wordt gerealiseerd. Power Apps is gemodelleerd naar Excel, waar meerdere exemplaren van een formule gebruikelijk zijn. In Excel zijn formules echter beperkt tot één uitdrukking en zijn ze beperkt tot 8.000 tekens. Power Apps-formules kunnen veel langer worden met de introductie van imperatieve logica en de ketenvormingsoperator (; of ;;, afhankelijk van de landinstelling).

De algemene oplossing is om lange formules op te splitsen in kleinere delen en de delen opnieuw te gebruiken, zoals we deden in het vorige gedeelte toen we de instructies Set/Collect veranderden in App.OnStart naar benoemde formules in App.Formulas. In andere programmeertalen worden herbruikbare onderdelen vaak subroutines of door de gebruiker gedefinieerde functies genoemd. U kunt benoemde formules zien als een eenvoudige vorm van een door de gebruiker gedefinieerde functie zonder parameters of neveneffecten.

Gebruik overal benoemde formules

In het eerdere voorbeeld gebruikten we benoemde formules als vervanging voor App.OnStart. U kunt ze echter overal in een app gebruiken om een berekening te vervangen.

Een van de schermen in de voorbeeldoplossing Hospital Emergency Response bevat bijvoorbeeld deze logica in 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
    }
);

Deze formule kan worden opgesplitst in een reeks benoemde formules. Het maakt de formule ook leesbaarder.

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

Eerder extraheerden we ParamFacility als een benoemde formule toen we de meeste Set-aanroepen verplaatsten van App.OnStart naar benoemde formules in App.Formulas.

Benoemde formules worden alleen geëvalueerd als hun waarden nodig zijn. Als het oorspronkelijke doel van het gebruik van Screen.OnVisible was om werk uit te stellen totdat het scherm word weergegeven, wordt het werk nog steeds uitgesteld als algemene benoemde formules in App.Formulas.

Gebruik de With-functie

U kunt ook de functie With in een formule gebruiken om logica op te splitsen. De kunst is om een record te maken in de eerste parameter met de gewenste waarden als velden en vervolgens die velden in de tweede parameter te gebruiken om de geretourneerde waarde te berekenen via With. Het vorige voorbeeld kan bijvoorbeeld worden geschreven als slechts één benoemde formule:

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

Een nadeel van het op deze manier gebruikmaken van With is dat MyFacility geen gebruik kan maken van MyRegion omdat ze zijn gedefinieerd in dezelfde With-functie, een probleem dat niet voorkomt bij benoemde formules. Eén oplossing is om With-functies te nesten en het trefwoord As te gebruiken om de record een naam te geven voor elk om gemakkelijke toegang te bieden tot alle With-variabelen.

Gebruik canvasonderdelen

Canvasonderdelen worden meestal gebruikt om een UI-besturingselement te maken dat net als een besturingselement op het canvas kan worden geplaatst. U kunt ze ook gebruiken zonder ze in de gebruikersinterface te plaatsen om berekeningen uit te voeren met aangepaste uitvoereigenschappen als alternatief voor benoemde formules. Canvasonderdelen zijn eenvoudig te delen tussen apps met componentbibliotheken en worden, in tegenstelling tot benoemde formules, volledig ondersteund. Ze zijn echter moeilijker te configureren en te gebruiken dan benoemde formules.

Het splitsen van logica:

  1. Schakel in Power Apps Studio naar het tabblad Onderdelen in de Structuurweergave.
  2. Een nieuw onderdeel maken.
  3. Schakel in het deelvenster Eigenschappen de optie Toegang tot app-bereik in.
  4. Voeg een aangepaste eigenschap toe.
  5. Stel Eigenschapstype in op Uitvoer en Gegevenstype op de gewenste waarde.
  6. Selecteer Maken.
  7. Selecteer de nieuwe eigenschap in de eigenschappenkiezer naast de formulebalk bovenaan het scherm.
  8. Schrijf de formule voor de logica om te splitsen en opnieuw te gebruiken.

Het gebruik van de logica:

  1. Schakel over naar het tabblad Schermen in de Structuurweergave.
  2. Vouw in het deelvenster Invoegen de optie Aangepast uit en voeg uw component in.
  3. Gebruik ComponentName.PropertyName om een waarde met de eigenschap te berekenen.

Gebruik Selecteren met een verborgen besturingselement voor imperatieve logica

Imperatieve logica wordt gebruikt om de status te wijzigen met Set en Collect, de gebruiker te informeren met Notify, naar een ander scherm of een andere app te navigeren met Navigate en Launch, en waarden te schrijven naar een database met Patch, SubmitForm of RemoveIf.

Benoemde formules en aangepaste uitvoereigenschappen van canvascomponenten ondersteunen geen dwingende logica. Een gebruikelijke manier om imperatieve logica op te splitsen is door de eigenschap OnSelect van een verborgen besturingselement te gebruiken.

  1. Voeg een besturingselement van het type Knop toe aan een scherm.
  2. Stel de eigenschap OnSelect in op de imperatieve logica die u wilt uitvoeren.
  3. Stel de Visible-eigenschap in op false, aangezien de gebruiker deze niet hoeft te zien of ermee te werken.
  4. Roep Select( Button ) wanneer u de imperatieve logica wilt uitvoeren.

Een van de schermen in ons voorbeeld heeft bijvoorbeeld de volgende OnSelect-eigenschap op een besturingselement Knop. (Dit eenvoudige voorbeeld is alleen ter illustratie. Normaal gesproken zou u deze techniek alleen gebruiken voor langere formules.)

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

Als u deze logica wilt opsplitsen, kunnen we delen bij afzonderlijke besturingselementen Knop plaatsen en deze selecteren vanuit het origineel:

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

Deze techniek werkt alleen op hetzelfde scherm. Andere technieken die iets ingewikkelder zijn, werken op verschillende schermen, zoals het gebruik van het besturingselement Wisselknop, het instellen OnCheck op de logica die u wilt uitvoeren, en Standaard instellen op een globale variabele en vervolgens de globale variabele schakelen met Set( global, true ); Set( global, false ) op het punt waarop u de logica wilt uitvoeren.

In dit voorbeeld was al enige logische splitsing al uitgevoerd. De opmerking vermeldt dat "Vervolgacties kunnen worden gevonden in OnSuccess." Deze gebeurtenis voert imperatieve logica uit nadat de record met succes is ingediend, een oplossing die specifiek is voor de functie SubmitForm.

Partitioneer de app

Sommige apps groeien uit tot duizenden bedieningselementen en honderden gegevensbronnen, wat Power Apps Studio vertraagt. Net als bij lange formules kunnen grote apps worden opgesplitst in kleinere secties die samenwerken om één gebruikerservaring te creëren.

Aparte canvas-apps

Een benadering is om secties in afzonderlijke canvas-apps te implementeren en de functie Launch te gebruiken om tussen de afzonderlijke apps te navigeren en de benodigde context door te geven.

Deze aanpak werd gebruikt in de Hospital Emergency Response-voorbeeldoplossing. Afzonderlijke apps beheren elk van de belangrijkste gebieden van de algehele app. De apps delen een gemeenschappelijke schakelbordcomponent via een componentenbibliotheek die elke app op het opstartscherm toont:

Schermopname van de canvas-app Hospital Emergency Response-voorbeeldoplossing die wordt uitgevoerd op een telefoon met weergave van het canvasonderdeel van het schakelbord

Wanneer de gebruiker een gebied selecteert, gebruikt het onderdeel metagegevens over de beschikbare apps en over welke app het onderdeel host. Als het gewenste scherm zich in deze app bevindt (daarmee wordt bedoeld dat ThisItem.Screen niet leeg is), vindt er vervolgens een Navigate-aanroep plaats. Maar als het gewenste scherm zich in een andere app bevindt (hiermee wordt bedoeld dat ThisItem.PowerAppID niet leeg is), wordt er een functie Launch gebruikt met de app-id van het doel en de FacilityID-context:

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

Status in de oorspronkelijke app gaat verloren wanneer een andere app wordt gestart. Zorg ervoor dat u een status opslaat voordat u de Launch-functie aanroept. Schrijf het naar een database, roep SaveData aan of geef de status door aan de doel-app met parameters die worden gelezen met de Param-functie.

Modelgestuurde app met aangepaste pagina's

Secties kunnen ook worden geïmplementeerd als aangepaste pagina's. Aangepaste pagina's fungeren als een mini-canvas-app met een modelgestuurde app-container voor navigatie.

Notitie

Laat ons uw taalvoorkeuren voor documentatie weten! Beantwoord een korte enquête. (houd er rekening mee dat deze in het Engels is)

De enquête duurt ongeveer zeven minuten. Er worden geen persoonlijke gegevens verzameld (privacyverklaring).