Créer des applications canevas volumineuses et complexes
La plupart des articles de cette section de la documentation couvrent les performances d’exécution des applications telles qu’elles sont expérimentées par les personnes qui les utilisent. Cet article couvre les performances des applications telles qu’elles sont expérimentées par les personnes qui les créent.
Au fur et à mesure que les applications deviennent plus volumineuses et complexes, Power Apps Studio doit charger et gérer un grand nombre de contrôles, de formules et de sources de données, tous avec des interdépendances qui augmentent de manière exponentielle. Le chargement de Power Apps Studio peut prendre plus de temps et les fonctionnalités telles qu’IntelliSense et le codage de couleurs peuvent subir des retards. Utilisez les recommandations qui suivent pour optimiser l’utilisation des applications volumineuses et complexes dans Power Apps Studio. Elles peuvent également aider à améliorer les performances d’exécution de vos applications.
Les exemples de cet article utilisent l’exemple de solution Réponse aux urgences des hôpitaux.
Utiliser App.Formulas au lieu de App.OnStart
Conseil
Vous pouvez utiliser les propriétés de sortie personnalisées de la fonction With et du composant canevas comme alternative aux formules nommées.
La meilleure façon de réduire le temps de chargement pour Power Apps Studio et votre application consiste à remplacer l’initialisation des variables et collections dans App.OnStart par des formules nommées dans App.Formulas.
Examinons l’exemple suivant, qui utilise 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
);
);
Comme il s’agit d’une séquence d’instructions, votre application doit évaluer ces appels Set et Collect dans l’ordre avant de pouvoir afficher le premier écran, ce qui ralentit le chargement de l’application. Et comme toute la App.OnStart doit être considérée comme un tout avec l’ordre conservé et les erreurs agrégées avant de renvoyer le résultat final, la formule est complexe à analyser pour Power Apps Studio.
Il existe une meilleure solution. Utilisez App.Formulas à la place et définissez ces variables et collections en tant que formules nommées, comme dans l’exemple suivant.
// 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()
);
Ce changement peut sembler minime, mais il peut avoir un impact énorme. Comme chaque formule nommée est indépendante des autres, Power Apps Studio peut les analyser indépendamment, en fractionnant efficacement une App.OnStart volumineuse en parties plus petites. Nous avons vu que le temps de chargement de Power Apps Studio baisse jusqu’à 80 % avec ce seul changement.
Votre application se charge également plus rapidement car elle n’a pas à évaluer ces formules jusqu’à ce qu’elle ait besoin du résultat. Le premier écran de l’application s’affiche immédiatement.
Les formules nommées ne peuvent pas être utilisées dans toutes les situations car vous ne pouvez pas les modifier ni les utiliser avec Set. Certaines situations nécessitent l’utilisation d’une variable d’état modifiable. Set est parfait pour ces situations et vous devriez continuer à l’utiliser. Mais, le plus souvent, vous utilisez des variables globales dans OnStart pour configurer des valeurs statiques qui ne changent pas. Dans ces cas, une formule nommée est le meilleur choix.
Étant donné que les formules nommées sont immuables, le préfixe var (abréviation de « variable ») comme convention d’affectation de noms n’est plus approprié. Nous n’avons pas modifié les noms dans cet exemple, car cela nécessiterait de modifier le reste de l’application pour correspondre.
Il est tentant de placer une formule nommée dans App.OnStart, mais ne le faites pas. Elles n’y ont pas leur place. En tant que propriété de comportement On, App.OnStart évalue chacune de ses instructions dans l’ordre, en créant des variables globales et en discutant avec les bases de données une seule fois lorsque l’application est chargée. Les formules nommées sont des formules qui définissent comment calculer quelque chose si nécessaire et sont toujours vraies. C’est la nature de cette formule qui leur permet d’être indépendantes et qui permet à l’application de terminer le chargement avant qu’elles ne soient évaluées.
Fractionner les formules longues
App.OnStart est l’un des pires contrevenants pour les formules longues et certainement par où vous devriez commencer, mais ce n’est pas le seul cas.
Nos études ont montré que presque toutes les applications avec un temps de chargement long pour Power Apps Studio ont au moins une formule de plus de 256 000 caractères. Certaines applications avec les temps de chargement les plus longs ont des formules de plus d’un million de caractères. Les formules de cette taille exercent une pression considérable sur Power Apps Studio.
Pour aggraver les choses, la copie et le collage d’un contrôle avec une longue formule dupliquent la formule dans les propriétés du contrôle sans que vous vous en rendiez compte. Power Apps suit le modèle Excel, où plusieurs copies d’une formule sont courantes. Cependant, dans Excel, les formules sont limitées à une expression et plafonnées à 8 000 caractères. Les formules Power Apps peuvent devenir beaucoup plus longues avec l’introduction de la logique impérative et de l’opérateur de chaînage (; ou ;;, selon les paramètres régionaux).
La solution générale consiste à fractionner les formules longues en parties plus petites et à réutiliser les parties, comme nous l’avons fait dans la section précédente où nous avons modifié les instructions Set/Collect dans App.OnStart en formules nommées dans App.Formulas. Dans d’autres langages de programmation, les parties réutilisables sont souvent appelées sous-routines ou fonctions définies par l’utilisateur. Vous pouvez considérer les formules nommées comme une forme simple de fonction définie par l’utilisateur sans paramètres ou effets secondaires.
Utiliser des formules nommées partout
Dans l’exemple précédent, nous avons utilisé des formules nommées en remplacement de App.OnStart. Cependant, vous pouvez les utiliser pour remplacer un calcul n’importe où dans une application.
Par exemple, l’un des écrans de l’exemple de solution Réponse aux urgences des hôpitaux inclut cette logique dans Écran.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
}
);
Cette formule peut être fractionnée en un ensemble de formules nommées. Cela facilite également la lecture de la 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
};
Nous avons extrait ParamFacility en tant que formule nommée plus tôt lorsque nous avons déplacé la plupart des appels Set de App.OnStart vers les formules nommées dans App.Formulas.
Les formules nommées ne sont évaluées que lorsque leurs valeurs sont nécessaires. Si l’intention initiale d’utiliser Écran.OnVisible était de différer le travail jusqu’à ce que l’écran s’affiche, le travail est toujours différé en tant que formules nommées globales dans App.Formulas.
Utiliser la fonction With
Vous pouvez également utiliser la fonction With dans une formule pour fractionner la logique. Créez un enregistrement dans le premier paramètre avec les valeurs que vous souhaitez utiliser comme champs, puis utilisez ces champs dans le deuxième paramètre pour calculer la valeur de retour de With. Par exemple, l’exemple précédent peut être écrit comme une seule formule nommée :
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
}
)
L’inconvénient d’utiliser With de cette manière est que MyFacility ne peut pas utiliser MyRegion car ils sont définis dans la même fonction With, un problème qui n’existe pas avec les formules nommées. Une solution consiste à imbriquer les fonctions With et à utiliser le mot clé As pour nommer l’enregistrement pour chacune d’elles pour faciliter l’accès à toutes les variables With.
Utiliser les composants de canevas
Les composants de canevas sont le plus souvent utilisés pour créer un contrôle d’interface utilisateur qui peut être placé dans le canevas comme un contrôle. Vous pouvez également les utiliser sans les placer dans l’interface utilisateur pour effectuer des calculs avec des propriétés de sortie personnalisées comme alternative aux formules nommées. Les composants de canevas sont faciles à partager entre les applications avec des bibliothèques de composants et, contrairement aux formules nommées, sont entièrement pris en charge. Cependant, ils sont plus difficiles à configurer et à utiliser que les formules nommées.
Pour fractionner la logique :
- Dans Power Apps Studio, basculez vers l’onglet Composants dans l’Arborescence.
- Création d’un composant.
- Dans le volet Propriétés, activez Accéder à la portée de l’application.
- Ajoutez une propriété personnalisée.
- Définissez le Type de propriété sur Sortie et le Type de données selon les besoins.
- Cliquez sur Créer.
- Dans le sélecteur de propriétés en regard de la barre de formule en haut de l’écran, sélectionnez la nouvelle propriété.
- Écrivez la formule de la logique à fractionner et à réutiliser.
Pour utiliser la logique :
- Passez à l’onglet Écrans dans l’Arborescence.
- Dans le volet Insérer, développez Personnalisé et insérez votre composant.
- Pour calculer une valeur avec la propriété, utilisez ComponentName.PropertyName.
Utiliser Select avec un contrôle masqué pour la logique impérative
La logique impérative est utilisée pour modifier l’état avec Set et Collect, notifier l’utilisateur avec Notify, accéder à un autre écran ou à une autre application avec Navigate et Launch et écrire des valeurs dans une base de données avec Patch, SubmitForm ou RemoveIf.
Les formules nommées et les propriétés de sortie personnalisées du composant de canevas ne prennent pas en charge la logique impérative. Une manière courante de fractionner la logique impérative consiste à utiliser la propriété OnSelect d’un contrôle masqué.
- Ajoutez un contrôle Bouton à un écran.
- Définissez la propriété OnSelect sur la logique impérative que vous souhaitez exécuter.
- Définissez la propriété Visible sur false, car l’utilisateur n’a pas besoin de la voir ni d’interagir avec elle.
- Appelez
Select( Button )lorsque vous souhaitez exécuter la logique impérative.
Par exemple, l’un des écrans de notre exemple a la propriété OnSelect suivante sur un contrôle Bouton. (Cet exemple simple est fourni à des fins d’illustration uniquement. Normalement, vous n’utilisez cette technique que pour des formules plus longues.)
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)
);
Pour fractionner cette logique en parties, nous pouvons insérer des parties dans des contrôles Bouton distincts et les Sélectionner à partir de l’original :
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 );
Cette technique ne fonctionne que sur le même écran. D’autres techniques légèrement plus compliquées fonctionnent sur plusieurs écrans, comme l’utilisation du contrôle Bouton à bascule, la définition de OnCheck sur la logique que vous souhaitez exécuter, la définition de Default sur une variable globale, puis le basculement de la variable globale avec Set( global, true ); Set( global, false ) au point où vous souhaitez exécuter la logique.
Dans cet exemple, un fractionnement de la logique a déjà été effectué. Le commentaire mentionne que « Les actions ultérieures sont disponibles dans OnSuccess. » Cet événement exécute la logique impérative une fois que l’enregistrement a été soumis correctement, une solution spécifique à la fonction SubmitForm.
Partitionner l’application
Certaines applications se transforment en milliers de contrôles et en centaines de sources de données, ce qui ralentit Power Apps Studio. Comme pour les formules longues, les applications volumineuses peuvent être fractionnées en sections plus petites qui fonctionnent ensemble pour créer une expérience utilisateur unique.
Applications canevas distinctes
Une approche consiste à implémenter des sections dans des applications canevas distinctes et à utiliser la fonction Launch pour naviguer entre les applications distinctes et transmettre le contexte nécessaire.
Cette approche a été utilisée dans l’exemple de solution Réponse aux urgences des hôpitaux. Les applications distinctes gèrent chacune des principaux zones de l’application globale. Les applications partagent un composant de panneau de contrôle commun via une bibliothèque de composants que chaque application affiche sur son écran de démarrage :
Lorsque l’utilisateur sélectionne une zone, le composant utilise des métadonnées sur les applications disponibles et sur l’application qui héberge le composant. Si l’écran souhaité se trouve dans cette application (c’est-à-dire ThisItem.Écran n’est pas vide), alors un appel Navigate est effectué. Mais si l’écran souhaité se trouve dans une application différente (c’est-à-dire ThisItem.PowerAppID n’est pas vide), alors une fonction Launch est utilisée avec l’ID d’application de la cible et le contexte 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
)
);
L’état de l’application d’origine est perdu lorsqu’une autre application est lancée. Assurez-vous d’enregistrer tout état avant d’appeler la fonction Launch. Écrivez-le dans une base de données, appelez SaveData ou transmettez l’état à l’application cible avec des paramètres qui sont lus avec la fonction Param.
Application pilotée par modèle avec pages personnalisées
Les sections peuvent également être implémentées en tant que pages personnalisées. Les pages personnalisées agissent comme une mini application canevas avec un conteneur d’applications pilotées par modèle pour la navigation.
Notes
Pouvez-vous nous indiquer vos préférences de langue pour la documentation ? Répondez à un court questionnaire. (veuillez noter que ce questionnaire est en anglais)
Le questionnaire vous prendra environ sept minutes. Aucune donnée personnelle n’est collectée (déclaration de confidentialité).
Commentaires
Prochainement : Tout au long de l'année 2024, nous supprimerons progressivement les GitHub Issues en tant que mécanisme de retour d'information pour le contenu et nous les remplacerons par un nouveau système de retour d'information. Pour plus d’informations, voir: https://aka.ms/ContentUserFeedback.
Soumettre et afficher des commentaires pour