Kompilowanie dużych i złożonych aplikacji kanwy
Większość artykułów w tej sekcji dokumentów zawiera informacje o wydajności środowiska uruchomieniowego aplikacji, której doświadczyli korzystające z nich osoby. W tym artykule o mowa o wydajności aplikacji, zgodnie z doświadczeniem osób je tworzących.
Gdy aplikacje stają się większe i złożone, program Power Apps Studio musi ładować dużą liczbę kontrolek, formuł i źródeł danych ze wszystkimi współzależnościami, które rosną w postępie geometrycznym, oraz zarządzać nimi. Czas ładowania aplikacji Power Apps Studio może się wydłużyć, a funkcje, takie jak IntelliSense i kodowanie kolorami mogą działać z opóźnieniem. Rekomendacje ułatwiają lepszą pracę z dużymi i złożonych aplikacjami w programie Power Apps Studio. Mogą one także przyczynić się do zwiększenia wydajności środowiska uruchomieniowego aplikacji.
Wszystkie przykłady w tym artykule używają przykładowego rozwiązania Reakcji kryzysowej szpitala.
Używanie elementu App.Formulas zamiast App.OnStart
Porada
Możesz użyć niestandardowych właściwości wyjściowych funkcji With i komponentem kanwy jako alternatywy dla nazwanych formuł.
Najlepszym sposobem, aby skrócić czas ładowania programu Power Apps Studio i aplikacji jest zastąpienie inicjowania zmiennej i kolekcji w funkcji App.OnStart formułami nazwanymi w funkcji App.Formulas.
Zwróćmy uwagę na poniższy przykład, na którym jest używana aplikacja 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
);
);
Ponieważ są sekwencją instrukcji, aplikacji musi ocenić takie wywołania Set i Collect zgodnie z kolejnością przed wyświetleniem pierwszego ekranu, co powoduje wydłużenie czasu ładowania aplikacji. Ponieważ cała funkcja App.OnStart musi być traktowana jak całość, z zachowaniem kolejności i zagregowanymi błędami przed zwróceniem wyniku końcowego, formula jest złożona dla analizy przez Power Apps Studio.
Istnieje lepszy sposób. Użyj zamiast tego funkcji App.Formulas i zdefiniuj te zmienne oraz kolekcje jako formuły nazwane, jak na poniższym przykładzie.
// 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()
);
Zmiana może wyglądać na niewielką, ale może mieć ogromny wpływ na Twoją pracę. Ponieważ każda nazwana formuła jest niezależna od innych, Power Apps Studio może analizować je niezależnie, skutecznie rozdzielając dużą App.OnStart na mniejsze części. Dzięki tej zmianie czas ładowania Power Apps Studio skrócił się nawet o 80%.
Aplikacja jest również ładowana szybciej, ponieważ nie trzeba oceniać tych formuł, dopóki nie będą potrzebne wyniki. Pierwszy ekran aplikacji zostanie wyświetlony natychmiast.
Formuł nazwanych nie można używać we wszystkich sytuacjach, ponieważ nie można ich zmodyfikować ani używać w zestawie. W niektórych sytuacjach wymagane jest użycie zmiennej stanu, która może być modyfikowana. Zestaw jest doskonały w takich sytuacjach i należy ustawić i nadal go używać. Jednak najczęściej używasz zmiennych globalnych w OnStart do skonfigurowania wartości statycznych, które się nie zmieniają. W tych przypadkach lepszym rozwiązaniem jest nazwana formuła.
Ponieważ formuły nazwane są niezmienne, var (skrót od angielskiego „variable” — zmienna) nie będzie już odpowiednią konwencją nazewnictwa. W tym przykładzie nie zmieniliśmy nazw, ponieważ wymaga to zmian w pozostałej części aplikacji.
Atrakcyjne może wydawać się umieszczenie formuły nazwanej w funkcji App.OnStart, ale nie jest to odpowiednie miejsce. Nie tutaj jest ich miejsce. Jako właściwość zachowania On funkcja App.OnStart ocenia wszystkie instrukcje w kolejności, tworząc zmienne globalne i komunikując się z bazami danych tylko raz podczas ładowania aplikacji. Formuły nazwane definiują sposób obliczania potrzebnych informacji, gdy są potrzebne. Formuły te są zawsze prawdziwe. Ten charakter formuły umożliwia jej zachowanie niezależności i umożliwia zakończenie ładowania aplikacji przed oszacowaniem formuł.
Dzielenie długich formuł
Element App.OnStart to jeden z najgorszych elementów do użycia w długich formułach, można od niego zacząć, ale nie jest to jedyna sprawa.
Z naszych badań wynika, że prawie wszystkie aplikacje z długim czasem ładowania programu Power Apps Studio mają co najmniej jedną formułę o długości ponad 256 000 znaków. Niektóre aplikacje z najdłuższymi czasamu ładowania pochłoną formuły o długości ponad 1 miliona znaków. Formuły, które od długiego czasu stanowią istotne obciążenie w Power Apps Studio.
Co gorsza, skopiowanie i wklejenie kontrolki z długą formułą powoduje nieświadome duplikowanie formuły we właściwościach kontrolki. Power Apps jest modelowane na przykładzie programu Excel, gdzie normalne jest wiele kopii formuł. Jednak w formułach programu Excel wyrażenie jest ograniczone do jednego wyrażenia i jego liczba nie może mieć więcej niż 8000 znaków. Formuły Power Apps mogą rosnąć do znacznie większych rozmiarów z powodu wprowadzenia logiki koniecznej i operatora łańcucha (; lub ;; lub w zależności od ustawień regionalnych).
Ogólne rozwiązanie to podzielenie długich formuł na mniejsze części i ponowne używanie części, jak zrobiliśmy w poprzedniej sekcji, gdzie zmieniliśmy istrukcje Set/Collect w funkcji App.OnStart do formuł nazwanych w funkcji App.Formulas. W innych językach programowania ponownie użyte części są często nazywane procedurami podrzędnymi lub funkcjami zdefiniowanymi przez użytkownika. Formuły nazwane mogą być traktowane jako prosty formularz funkcji zdefiniowanych przez użytkownika bez parametrów i bez efektów ubocznych.
Korzystanie z formuł nazwanych w dowolnym miejscu
We wcześniejszym przykładzie używaliśmy nazwanych formuł jako zamiennika App.OnStart. Możesz ich jednak użyć do zastąpienia obliczeń w dowolnym miejscu aplikacji.
Na przykład jeden z ekranów w Przykładowym rozwiązaniu do reagowania w nagłych wypadkach w szpitalu zawiera tę logikę w 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
}
);
Formułę można podzielić na zestaw nazwanych formuł. Ułatwiają one również odczytywanie formuł.
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
};
Element ParamFacility został wcześniej wyodrębniony jako formuła nazwana, gdy przenieśliśmy większość wywołać Set z funkcji App.OnStart do formuł nazwanych w funkcji App.Formulas.
Formuły nazwane są obliczane tylko wtedy, gdy są potrzebne ich wartości. Jeśli pierwotną intencją użycia funkcji Screen.OnVisible było odroczenie pracy do momentu wyświetlenia ekranu, praca będzie nadal odraczana jako globalne formuły nazwane w funkcji App.Formulas.
Korzystanie z funkcji With
Aby rozdzielić logikę With, można także użyć funkcji w formule. Należy utworzyć rekord w pierwszym parametrze z wartościami żądanymi jako polami, a następnie użycie tych pól w drugim parametrze do obliczenia wartości zwróconej z funkcji With. Na przykład poprzedni przykład można zapisać jako tylko jedna formułę nazwaną:
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
}
)
Jedną z wad używania w ten sposób With jest fakt, że element MyFacility nie może używać elementu MyRegion, ponieważ zostały zdefiniowane w ramach tego samej funkcji With. Ten problem nie występuje w formułach nazwanych. Jednym z rozwiązań jest zagnieżdżenie funkcji With i użycie słowa kluczowego As w celu uzyskania łatwego dostępu do wszystkich funkcji zmiennych With.
Korzystanie ze składników kanwy
Składniki kanwy są najczęściej używane do tworzenia kontrolki interfejsu użytkownika, którą można umieścić na kanwie tak jak kontrolkę. Można ich także używać bez umieszczania ich w interfejsie użytkownika do wykonywania obliczeń, których niestandardowe właściwości danych wyjściowych mogą być alternatywą dla formuł nazwanych. Składniki kanwy są łatwe do udostępnienia w aplikacjach w bibliotekach składników i są w pełni obsługiwane w przeciwieństwie do formuł nazwanych. Trudno je jednak skonfigurować i używać niż nazwane formuły.
Aby podzielić logikę:
- W Power Apps Studio przełącz się na kartę Składniki w oknie Widok drzewa.
- Utworzenie nowego składnika.
- W okienku Właściwości włącz opcję Dostęp do zakresu aplikacji.
- Dodaj właściwość niestandardową.
- Ustaw Typ właściwości na Dane wyjściowe oraz odpowiedni Typ danych.
- Wybierz pozycję Utwórz.
- Wybierz nowo utworzoną właściwość w selektorze właściwości obok paska formuł w górnej części ekranu.
- Napisz formułę dla logiki do podziału i ponownego użycia.
Aby użyć logiki:
- Przełącz się na kartę Ekrany w oknie Widok drzewa.
- W okienku Wstaw rozwiń pozycję Niestandardowe i wstaw składnik.
- Do obliczenia wartości przy użyciu tej właściwości użyj elementu ComponentName.PropertyName.
Korzystanie z opcji wybierania z ukrytą kontrolką na potrzeby logiki koniecznej
Logika konieczna umożliwia modyfikowanie stanu przy użyciu instrukcji Set i Get, powiadamianie użytkownika przy użyciu funkcji Notify, przechodzenie do innego ekranu lub aplikacji przy użyciu funkcji Navigate i Launch, a także zapisywanie wartości z powrotem w bazie danych przy użyciu funkcji Patch, SubmitForm lub RemoveIf.
Właściwości danych wyjściowych formuły nazwanej i niestandardowy składnik kanwy składnika kanwy nie obsługują logiki koniecznej. Typowym trikiem dotyczącym dzielenia logiki koniecznej jest użycie właściwości OnSelect ukrytej kontrolki.
- Dodaj kontrolkę Przycisk do ekranu.
- Ustaw właściwość OnSelect na logikę konieczną do wykonania.
- Właściwość Visible należy ustawić jako fałsz, ponieważ użytkownik nie musi ich widzieć ani wchodzić z nimi w interakcję.
- Wywołaj element
Select( Button ), gdy chcesz wykonać logikę konieczną.
Na przykład na jednym z ekranów w naszym przykładzie jest dostępna właściwość OnSelect w kontrolce Przycisk. (Ten prosty przykład jest tylko do celów ilustracyjnych. Zazwyczaj ta metoda jest stosowana tylko w przypadku dłuższych formuł).
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)
);
Aby podzielić tę logikę na części, możemy umieścić części w oddzielnych kontrolkach Przycisk i wybrać je z oryginału:
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 metoda działa tylko na tym samym ekranie. Inne techniki, które są nieco bardziej skomplikowane na ekranach, np. użycie formantu Przełącznik, ustawienie OnCheck do logiki, którą chcesz uruchomić, i ustawienie domyślnych wartości do zmiennej globalnej, a następnie uruchomienie zmiennej globalnej z Set( global, true ); Set( global, false ) w czasie, gdy chcesz uruchomić logikę.
W tym przykładzie podział logiki został już wykonany. W komentarzu wspomniano, że „Następne akcje można znaleźć w OnSuccess”. To zdarzenie uruchamia logikę konieczną po pomyślnym przesłaniu rekordu, czyli zastosowaniu rozwiązania specyficznego dla funkcji SubmitForm.
Dzielenie aplikacji na partycje
Niektóre aplikacje rosną do tysięcy kontrolek i setek źródeł danych, co spowalnia Power Apps Studio. Podobnie jak w przypadku długich formuł duże aplikacje można podzielić na mniejsze sekcje, które działają razem, aby utworzyć jedno środowisko użytkownika.
Dzielenie aplikacji kanwy
Jednym ze podejść jest implementacja sekcji w oddzielnych aplikacjach kanw i użycie funkcji Launch do przechodzenia między oddzielnymi aplikacjami i przekazania wymaganego kontekstu.
Ta metoda została wykorzystana w przykładowym rozwiązaniu Reakcja kryzysowa szpitala. Oddzielne aplikacje zarządzają wszystkimi głównymi obszarami całej aplikacji. Aplikacje współużytkują wspólny składnik tablicy rozdzielczej za pośrednictwem biblioteki składników, która jest pokazywana na ekranie uruchamiania każdej z aplikacji:
Gdy użytkownik wybierze obszar, składnik korzysta z metadanych dostępnych aplikacji i określa, która aplikacja hostuje składnik. Jeśli żądany ekran jest w tej aplikacji (element ThisItem.Screen nie jest pusty), zostanie wykonane wywołanie Nawiguj. Jeśli jednak żądany ekran znajduje się w innej aplikacji (element ThisItem.PowerAppID nie jest pusty), funkcja Launch jest używane z identyfikatorem aplikacji obiektu docelowego i kontekstem 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
)
);
Stan w oryginalnej aplikacji jest tracony po uruchomieniu innej aplikacji. Przed uruchomieniem funkcji Launch należy zapisać dowolny stan. Zapisz go w bazie danych, wywołując funkcję SaveData lub przekaż stan do aplikacji docelowej za pomocą parametrów odczytywanych za pomocą funkcji Param.
Aplikacja oparta na modelu ze stronami niestandardowymi
Sekcje można też implementować jako strony niestandardowe. Podczas nawigacji strony niestandardowe działają jako mini aplikacja kanwy z kontenerem aplikacji opartej na modelu.
Uwaga
Czy możesz poinformować nas o preferencjach dotyczących języka dokumentacji? Wypełnij krótką ankietę. (zauważ, że ta ankieta jest po angielsku)
Ankieta zajmie około siedmiu minut. Nie są zbierane żadne dane osobowe (oświadczenie o ochronie prywatności).