Споделяне чрез

Създаване на големи и сложни приложения за платно

  • Статия

Повечето от статиите в този раздел на документацията обхващат производителността на приложенията по време на изпълнение, както е изпитана от хората, които ги използват. Тази статия разглежда ефективността на приложенията на хората, които ги създават.

Тъй като приложенията стават все по-големи и по-сложни, Power Apps Studio трябва да зареждат и управляват по-голям брой контроли, формули и източници на данни, всички с взаимозависимости, които нарастват експоненциално. Power Apps Studio зареждането може да отнеме повече време, а функции като IntelliSense и цветно кодиране могат да изостават. Използвайте препоръките, които следват, за да работите по-добре с големи и сложни приложения Power Apps Studio. Те също могат да помогнат за подобряване на производителността на вашите приложения по време на изпълнение.

Примерите в тази статия използват примерния разтвор за спешен отговор на болницата.

Използване на App.Formulas вместо App.OnStart

Съвет

Можете да използвате персонализирани изходни свойства на компонента на функцията и платното като алтернатива на наименуваните формули.

Най-добрият начин да намалите времето за зареждане и за двете Power Apps Studio и за вашето приложение е да замените инициализацията на променливата и колекцията в App.OnStart с именувани формули в App.Formulas.

Нека разгледаме следния пример, който използва 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
    );
);

Тъй като те са поредица от извлечения, приложението ви трябва да оцени тези извиквания по ред, преди да може да покаже първия екран, което прави приложението да се зарежда по-бавно. И тъй като целият App.OnStart трябва да се разглежда като цяло, редът е запазен и грешките да се обобщят, преди да се върне крайният резултат, формулата е сложна за Power Apps Studio анализ.

Има по-добър начин. Вместо това използвайте App.Formulas и дефинирайте тези променливи и колекции като именувани формули, както е в следващия пример.

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

Тази промяна може да изглежда малка, но може да има огромно въздействие. Тъй като всяка именувана формула е независима от останалите, Power Apps Studio може да ги анализира независимо, ефективно разделяйки голямо приложение.OnStart на по-малки части. Видяхме Power Apps Studio как времето за зареждане намалява с до 80% само с тази промяна.

Приложението ви също се зарежда по-бързо, защото не е необходимо да оценява тези формули, докато не се нуждае от резултата. Първият екран на приложението се показва веднага.

Именуваните формули не могат да се използват във всички ситуации, защото не можете да ги променяте или да ги използвате със Set. Някои ситуации изискват използването на променлива на състоянието, която може да бъде модифицирана. Комплектът е идеален за тези ситуации и трябва да продължите да го използвате. Но най-често използвате глобални променливи в OnStart, за да настроите статични стойности, които не се променят. В тези случаи наименуваната формула е по-добрият избор.

Тъй като именуваните формули са неизменни, префиксът var (съкратено от "променлива") като конвенция за именуване вече не е подходящ. Не променихме имената в този пример, защото ще са необходими промени в останалата част от приложението, за да съвпадат.

Изкушаващо е да поставите именувана формула в App.OnStart, но не го правете. Те не принадлежат там. Като свойство на поведението On, App.OnStart оценява всяка от своите инструкции по ред, създавайки глобални променливи и разговаряйки с бази данни само веднъж, когато приложението се зареди. Именуваните формули са формули, които определят как да се изчисли нещо , когато е необходимо, и винаги са верни. Именно тази природа на формулата им позволява да бъдат независими и позволява на приложението да завърши зареждането, преди да бъдат оценени.

Разделяне на дълги формули

App.OnStart е един от най-лошите нарушители на дълги формули и определено откъде трябва да започнете, но това не е единственият случай.

Проучванията ни показват, че почти всички приложения с дълго време за зареждане имат Power Apps Studio поне една формула от повече от 256 000 знака. Някои приложения с най-дълго време за зареждане имат формули от над 1 милион знака. Формули, които дълго време натоварват Power Apps Studio значително.

За да влоши нещата, копирането и поставянето на контрола с дълга формула дублира формулата в свойствата на контролата, без тя да бъде реализирана. Power Apps е моделиран по модела на Excel, където са често срещани множество копия на формула. В Excel обаче формулите са ограничени до един израз и са ограничени до 8,000 знака. Power Apps Формулите могат да станат много по-дълги с въвеждането на императивна логика и оператора за верига (; или ;;, в зависимост от локализацията).

Общото решение е да разделим дългите формули на по-малки части и да използваме повторно частите, както направихме в предишния раздел, когато променихме Set/Collect оператори в App.OnStart на именувани формули в App.Formulas. В други езици за програмиране частите за многократна употреба често се наричат подпрограми или дефинирани от потребителя функции. Можете да мислите за именуваните формули като за проста форма на дефинирана от потребителя функция без параметри или странични ефекти.

Използвайте наименувани формули навсякъде

В по-ранния пример използвахме именувани формули като заместител на App.OnStart. Можете обаче да ги използвате, за да замените изчисление навсякъде в приложението.

Например един от екраните в примерното решение за спешен отговор на болница включва тази логика в 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
    }
);

Тази формула може да бъде разделена на набор от именувани формули. Освен това прави формулата по-лесна за четене.

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 като именувана формула по-рано, когато преместихме повечето от извикванията на Set от App.OnStart към именувани формули в App.Formulas.

Именуваните формули се оценяват само когато са необходими техните стойности. Ако първоначалното намерение на използването на Screen.OnVisible е било да се отложи работата, докато екранът не бъде показан, тогава работата все още се отлага като глобални формули с имена в App.Formulas.

Използвайте функцията С

Можете също да използвате функцията With във формула, за да разделите логиката. Създайте запис в първия параметър със стойностите, които искате да използвате като полета, и след това използвайте тези полета във втория параметър, за да изчислите връщаната стойност от With. Например, предишният пример може да бъде записан само като една именувана формула:

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

Един недостатък на използването на With this way е, че MyFacility не може да се използва MyRegion , защото те са дефинирани в една и съща функция With, проблем, който не присъства при именуваните формули. Едно от решенията е да се вложат функции With и да се използва ключовата дума As , за да се наименува записът за всеки, за да се осигури лесен достъп до всички променливи With .

Използвайте компоненти на платното

Компонентите на платното най-често се използват за създаване на UI контрола, която може да бъде поставена върху платното точно като контрола. Можете също да ги използвате, без да ги поставяте в потребителския интерфейс, за да извършвате изчисления с потребителски изходни свойства като алтернатива на наименуваните формули. Компонентите на платното са лесни за споделяне между приложения с библиотеки на компоненти и, за разлика от именуваните формули, се поддържат напълно. Те обаче са по-трудни за конфигуриране и използване от именуваните формули.

За да разделите логиката:

  1. Влезте Power Apps Studio, превключете към раздела Компоненти в дървовидния изглед.
  2. Създаване на нов компонент.
  3. В екрана Свойства включете обхвата на приложението Access.
  4. Добавяне на персонализирано свойство.
  5. Задайте типа на свойството на Изход и типа данни според случая.
  6. Изберете Създаване.
  7. В инструмента за избор на свойства до лентата с формули в горната част на екрана изберете новото свойство.
  8. Напишете формулата за логиката за разделяне и повторно използване.

За да използвате логиката:

  1. Превключете към раздела Екрани в дървовидния изглед.
  2. В екрана Вмъкване разгънете По избор и вмъкнете вашия компонент.
  3. За да изчислите стойност със свойството, използвайте ComponentName.PropertyName.

Използване на Select със скрита контрола за императивна логика

Императивната логика се използва за промяна на състоянието с Задаване и събиране , уведомяване на потребителя с Известяване , навигиране до друг екран или приложение с Навигиране и стартиране и записване на стойности в база данни с Patch , SubmitForm или RemoveIf . ·

Наименуваните формули и персонализираните изходни свойства на компонента на платното не поддържат императивна логика. Често срещан начин за разделяне на императивната логика е да се използва свойството OnSelect на скрита контрола.

  1. Добавяне на контрола Бутон към екран.
  2. Задайте свойството OnSelect на императивната логика, която искате да изпълните.
  3. Задайте свойството Visible на false, тъй като няма нужда потребителят да го вижда или да взаимодейства с него.
  4. Обадете Select( Button ) се, когато искате да изпълните императивната логика.

Например един от екраните в нашия пример има следното свойство OnSelect в контрола Бутон . (Този прост пример е само с илюстративна цел. Обикновено бихте използвали тази техника само за по-дълги формули.)

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

За да разделим тази логика на части, можем да поставим части в отделни контроли на бутона и да ги изберем от оригинала:

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

Тази техника работи само на един и същ екран. Други техники, които са малко по-сложни, работят на различни екрани, като използване на контролата Toggle, задаване на OnCheck на логиката, която искате да изпълните, и задаване на Default на глобална променлива и след това превключване на глобалната променлива в Set( global, true ); Set( global, false ) точката, в която искате да изпълните логиката.

В този пример вече е направено известно логическо разделяне. В коментара се споменава, че "Последващи действия могат да бъдат намерени в OnSuccess". Това събитие изпълнява императивна логика, след като записът е изпратен успешно, решение, специфично за функцията SubmitForm .

Разделяне на приложението

Някои приложения растат до хиляди контроли и стотици източници на данни, което се забавя Power Apps Studio. Както при дългите формули, големите приложения могат да бъдат разделени на по-малки секции, които работят заедно, за да създадат едно потребителско изживяване.

Отделни приложения за платно

Един от подходите е да се внедрят секции в отделни приложения за платно и да се използва функцията за стартиране, за да се навигира между отделните приложения и да се предаде необходимия контекст.

Този подход е използван в решението за проба за спешен отговор на болниците. Отделни приложения управляват всяка от основните области на цялото приложение. Приложенията споделят общ компонент на комутационното табло чрез библиотека с компоненти, която всяко приложение показва на стартовия си екран:

Екранна снимка на приложението за платно за решение за спешна отговор на болница, работещо на телефон, показващо компонента на платното на централата.

Когато потребителят избере област, компонентът използва метаданни за наличните приложения и кое приложение хоства компонента. Ако желаният екран е в това приложение (т.е. ThisItem.Screen не е празен), тогава се прави повикване за навигация . Но ако желаният екран е в друго приложение (т.е. ThisItem.PowerAppID не е празен), тогава се използва функция за стартиране с ИД на приложението на целта и контекста на 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
    )
);

Състоянието в оригиналното приложение се губи при стартиране на друго приложение. Не забравяйте да запазите всяко състояние, преди да извикате функцията за стартиране . Запишете го в база данни, извикайте SaveData или предайте състояние на целевото приложение с параметри, които се четат с функцията Param .

Приложение, управлявано от модел, с персонализирани страници

Секциите могат да бъдат реализирани и като персонализирани страници. Персонализираните страници действат като мини приложение за платно с контейнер на приложение, управлявано от модел, за навигация.

Бележка

Можете ли да ни споделите повече за езиковите си предпочитания за документацията? Попълнете кратко проучване. (имайте предвид, че това проучване е на английски език)

Проучването ще отнеме около седем минути. Не се събират лични данни (декларация за поверителност).