Optimisation du code

À mesure que les applications canevas évoluent pour répondre aux diverses exigences de l’entreprise, le défi consistant à maintenir des performances optimales devient une considération cruciale. Les subtilités de la gestion des données, de la conception de l’interface utilisateur et des fonctionnalités au sein des applications canevas nécessitent une approche nuancée de l’optimisation du code.

À mesure que les applications canevas deviennent plus complexes, les développeurs sont confrontés à des défis liés à la récupération des données, à la complexité des formules et aux vitesses de rendu. La nécessité de trouver un équilibre entre des fonctionnalités robustes et des interfaces utilisateur réactives souligne l’importance d’adopter une approche systématique de l’optimisation du code.

Optimisation des formules Power Fx

Fonction With

La fonction With évalue une formule pour un seul enregistrement. La formule peut calculer une valeur et/ou effectuer des actions telles que la modification de données ou l’utilisation d’une connexion. Utilisez With pour améliorer la lisibilité des formules complexes en les divisant en sous-formules nommées plus petites. Ces valeurs nommées agissent comme de simples variables locales limitées à la portée de la fonction With. L’utilisation de la fonction With est préférée aux variables de contexte ou globales, car elle est autonome, facile à comprendre et peut être utilisée dans n’importe quel contexte de formule déclarative. En savoir plus sur la fonction With.

Fonction Concurrent

La fonction Concurrent permet à plusieurs formules spécifiées dans la même propriété d’être évaluées en même temps si elles ont des appels de connecteur ou Dataverse. En général, l’opérateur ; (point-virgule) sert à lier plusieurs formules entre elles, qui sont ensuite évaluées séquentiellement. Avec la fonction Concurrent, l’application évalue simultanément toutes les formules d’une propriété même après avoir utilisé l’opérateur ;. Cette simultanéité laisse patienter les utilisateurs moins longtemps pour le même résultat. Quand les appels de données ont lieu successivement, le délai d’attente de l’application est égal à la somme des durées de toutes les requêtes. Si les appels de données démarrent en même temps, le délai d’attente de l’application est réduit à la durée de la requête la plus longue. En savoir plus sur la fonction Concurrent.

Concurrent(
    ClearCollect(colAccounts1, Accounts),
    ClearCollect(colUsers1, Users),
    ClearCollect(colEnvDef1, 'Environment Variable Definitions'),
    ClearCollect(colEnvVal1, 'Environment Variable Values')
);

Fonction Coalesce

La fonction Coalesce évalue ses arguments dans l’ordre et retourne la première valeur non vide ou une chaine vide. Utilisez cette fonction pour remplacer une valeur vide ou une chaîne vide par une valeur différente sans modifier les valeurs ou les chaînes qui ne sont pas vides. Si tous les arguments sont des chaînes vides, la fonction renvoie vide, faisant de Coalesce un bon moyen de convertir des chaînes vides en valeurs vides.

Par exemple :

If(Not IsBlank(value1), value1, Not IsBlank(value2), value2)

Nécessite que la valeur 1 et la valeur 2 soient évaluées deux fois. Cette fonction peut être réduite à :

Coalesce(value1, value2)

Fonction IsMatch

La fonction IsMatch teste si une chaîne de texte correspond à un modèle qui peut comprendre des caractères ordinaires, des modèles prédéfinis ou une expression régulière. En savoir plus sur la fonction IsMatch.

Par exemple, cette formule correspond à un numéro de sécurité sociale aux États-Unis :

IsMatch(TextInput1.Text, "\d{3}-\d{2}-\d{4}")

Explication de l’expression régulière :

\\d Correspond à n’importe quel chiffre (0-9).

{3} Spécifie que le modèle de chiffre précédent (\d) devrait se produire exactement trois fois.

- Correspond au caractère de trait d’union.

{2} Spécifie que le modèle de chiffre précédent (\d) devrait se produire exactement deux fois.

{4} Spécifie que le modèle de chiffre précédent (\d) devrait se produire exactement quatre fois.

Autres exemples de IsMatch :

IsMatch(TextInput1.Text, "Hello World")
IsMatch(TextInput1\_2.Text, "(?!^\[0-9\]\\\*$)(?!^\[a-zA-Z\]\\\*$)(\[a-zA-Z0-9\]{8,10})")

Optimiser l’application OnStart

La propriété OnStart pour les applications cavenas joue un rôle crucial dans la définition des actions qui se produisent au lancement de l’application. Cette propriété permet aux développeurs d’applications d’exécuter des tâches d’initialisation globales, de configurer des variables et d’effectuer des actions qui ne doivent se produire qu’une seule fois au cours du processus de démarrage de l’application. Comprendre et utiliser efficacement la propriété OnStart est essentiel pour créer des applications canevas réactives et efficaces.

Une approche recommandée consiste à rationaliser la fonction App.OnStart en migrant les configurations de variables vers des formules nommées. Les formules nommées, en particulier celles configurées au début du cycle de vie de l’application, s’avèrent avantageuses. Ces formules gèrent l’initialisation des variables basées sur des appels de données, en offrant une structure plus propre et organisée pour votre code. Pour plus de détails : Créer des applications canevas volumineuses et complexes - Power Apps | Microsoft Learn.

Nonte

La propriété OnStart est Impérative. Il s’agit d’une liste ordonnée de travail qui doit être effectué avant que le premier écran ne s’affiche. Parce qu’elle est si spécifique non seulement sur ce qui doit être fait, mais aussi quand ce travail doit être fait en fonction de l’ordre, elle limite la réorganisation et le report des optimisations qui pourraient autrement être effectuées.

Lancer l’écran

Si App.OnStart contient un appel de la fonction Navigate, même si elle se trouve dans une fonction If et est rarement appelée, nous devons terminer l’exécution de l’application. OnStart avant d’afficher le premier écran de l’application.  App.StartScreen est la nouvelle manière déclarative d’indiquer quel écran doit être affiché en premier, qui ne bloque pas les optimisations.

La définition de la propriété StartScreen affiche le premier écran avant que App.OnStart ne soit terminé. App.StartScreen declares quel objet à l’écran afficher en premier sans nécessiter aucun prétraitement.

Au lieu d’écrire du code tel que :

App.OnStart = Collect(OrdersCache, Orders);
If(Param("AdminMode") = "1", Navigate(AdminScreen), Navigate(HomeScreen))

Modifiez le code en :

App.OnStart = Collect(OrdersCache, Orders);
App.StartScreen = If(Param("AdminMode") = "1", AdminScreen, HomeScreen)

Reportez-vous à <https://Power Apps.microsoft.com/en-us/blog/app-startscreen-a-new-declarative-alternative-to-navigate-in-app-onstart/> pour obtenir plus de détails.

Avertissement 

Évitez les dépendances entre StartScreen et OnStart. Référencer une formule nommée qui à son tour référence à une variable globale peut causer une condition de concurrence dans laquelle StartScreen n’est pas appliqué correctement. Note : nous ne devrions pas avoir de dépendances entre StartScreen et OnStart. Nous bloquons le référencement des variables globales dans StartScreen, mais nous pouvons référencer une formule nommée, qui à son tour référence une variable globale, et qui peut causer une condition de concurrence dans laquelle StartScreen n’est pas appliqué correctement.

Formules nommées

Les formules nommées sont statiques ou des constantes qui peuvent être définies dans la section App.Formulas. Une fois déclarées dans App.Formulas, elles peuvent être utilisées n’importe où dans l’application et leur valeur est toujours actualisée. Les formules nommées dans Power Apps permettent la définition de valeurs ou d’ensembles de valeurs qui sont automatiquement gérées et mises à jour par la plateforme. Cette fonctionnalité transfère la responsabilité du calcul de la valeur et de la maintenance du développeur à Power Apps, ce qui simplifie le processus de développement. Les formules nommées dans Power Apps sont une fonctionnalité puissante qui peut améliorer considérablement les performances et la maintenabilité des applications.

Les formules nommées peuvent également résoudre la déclaration des thèmes de l’application. Dans de nombreux cas où des applications d’entreprise sont créées, nous souhaitons que l’application dispose de thèmes communs pour offrir une apparence et une expérience utilisateur cohérentes. Pour créer un thème, des dizaines et des centaines de variables doivent être déclarées sur l’application OnStart. Cela a augmenté la longueur du code et le temps d’initialisation de l’application.

Les contrôles modernes peuvent également aider de manière significative avec les thèmes et contribuer à réduire la logique écrite par le client pour gérer les thèmes. Les contrôles modernes sont actuellement en version préliminaire.

Par exemple, le code suivant sur App.OnStart peut être déplacé vers App.Formulas, réduisant ainsi le temps de démarrage des déclarations de variables globales.

Set(BoardDark, RGBA(181,136,99, 1));
Set(BoardSelect, RGBA(34,177,76,1));
Set(BoardRowWidth, 10);                      // expected 8 plus two guard characters for regular expressions.
Set(BoardMetadata, 8 \* BoardRowWidth + 1);   // which player is next, have pieces moved for castling rules, etc.
Set(BoardBlank, "----------------------------------------------------------------\_00000000000000");
Set(BoardClassic, "RNBQKBNR\_\_PPPPPPPP------------------------\_--------\_\_pppppppp\_\_rnbqkbnr\_\_0000000000");

Le code peut être déplacé vers App.Formulas comme suit :

BoardSize = 70;
BoardLight = RGBA(240,217,181, 1);
BoardDark = RGBA(181,136,99, 1);
BoardSelect = RGBA(34,177,76,1);
BoardRowWidth = 10;                      // expected 8 plus two guard characters for regular expressions
BoardMetadata = 8 \* BoardRowWidth + 1;   // which player is next, have pieces moved for castling rules, etc.
BoardBlank = "----------------------------------------------------------------\_00000000000000";
BoardClassic = "RNBQKBNR\_\_PPPPPPPP------------------------\_--------\_\_pppppppp\_\_rnbqkbnr\_\_0000000000";

Un autre exemple est le paramètre inn Lookups. Ici, une modification est requise dans une formule de recherche pour obtenir les informations sur l’utilisateur à partir d’Office 365, au lieu de Dataverse. Il n’y a qu’un seul endroit où la modification est requise sans modifier le code partout.

UserEmail = User().Email;
UserInfo = LookUp(Users, 'Primary Email' = User().Email);
UserTitle = UserInfo.Title;
UserPhone = Switch(UserInfo.'Preferred Phone', 'Preferred Phone (Users)'.'Mobile Phone', UserInfo.'Mobile Phone',
UserInfo.'Main Phone');

Ces formules incarnent l’essence du calcul. Elles articulent le processus pour déterminer UserEmail, UserInfo, UserTitle et UserPhone en fonction d’autres valeurs. Cette logique est encapsulée, permettant une utilisation généralisée dans toute l’application, et peut être modifiée dans un emplacement unique. L’adaptabilité s’étend au passage de la table Utilisateurs Dataverse au connecteur Office 365 sans nécessiter de modifications des formules dispersées dans l’application.

Une autre approche consiste à optimiser countRows.

varListItems = CountRows(SampleList)

Avec la fonction Set, la variable varListItems devra être initialisée avec le nombre initial de lignes dans l’exemple de liste et définie à nouveau après l’ajout ou la suppression des éléments de la liste. Avec les formules nommées, à mesure que les données sont modifiées, les variables varListitems sont automatiquement mises à jour.

Les formules nommées dans la propriété App.Formulas offrent une approche plus flexible et déclarative pour la gestion des valeurs et des calculs dans l’ensemble de l’application, en offrant des avantages en termes d’indépendance temporelle, de mises à jour automatiques, de maintenabilité et de définitions immuables au lieu de se baser exclusivement sur App.OnStart.

Aspect	Formules nommées (App.Formulas)	App.OnStart
Indépendance temporelle	Les formules sont disponibles instantanément et peuvent être calculées dans n’importe quel ordre.	Les variables peuvent introduire des dépendances temporelles, qui affectent la disponibilité.
Mises à jour automatiques	Les formules sont automatiquement mises à jour lorsque les dépendances sont modifiées.	Les variables sont définies une fois au démarrage ; des mises à jour manuelles peuvent être nécessaires.
Maintenabilité	Les formules centralisées dans un seul endroit améliorent la maintenabilité.	Les variables dispersées peuvent nécessiter des recherches et des mises à jour dans plusieurs endroits.
Définitions immuables	Les définitions de formule dans App.Formulas sont immuables.	Les valeurs de variables peuvent être sujettes à des modifications accidentelles.

Fonctions définies par l’utilisateur

Les fonctions définies par l’utilisateur sont une fonctionnalité expérimentale dans le studio de création Power Apps qui permet aux utilisateurs de créer leur propre fonction personnalisée.

Pour utiliser cette fonctionnalité, dans les paramètres expérimentaux, sélectionnez Nouveau moteur d’analyse et Fonction définie par l’utilisateur (UDF)

Définissez une formule sous App.Formulas comme suit :

FunctionName(Parameter1:DataType1, Parameter2:DataType2):OutputDataType = Formula

Le code fonctionne comme suit :

• FunctionName est utilisé pour appeler la fonction

• Parameter est le nom de l’entrée. Une ou plusieurs entrées sont autorisées

• DataType est un argument transmis dans la fonction qui doit correspondre à ce type de données. Les types de données disponibles incluent Booléen, Couleur, Date, Date et heure, GUID, Lien hypertexte, Texte, Heure, Objet sans type

• OutputDataType est le type de données pour la sortie de la fonction

• Formula est la sortie de la fonction

// Function to calculate the area of a circle based on the radius
calcAreaOfCircle(radius: Number): Number = 
    IfError(Pi() * radius * radius, 0);

Utilisez IfError pour implémenter la gestion des erreurs dans la fonction définie.

Appelez la fonction définie à partir du contrôle de texte/étiquette.

calcAreaOfCircle(Int(*TextInput1*.Text))

Nonte

Il s’agit d’une fonctionnalité expérimentale qui est susceptible d’être modifiée. Certains types de données, tels que les enregistrements et les filtres, ne sont pas encore pris en charge.

Optimiser les variables

Les variables sont utilisées pour définir et configurer des valeurs locales et globales à utiliser partout dans les applications. Bien qu’elles soient pratiques, un trop grand nombre d’entre elles peuvent rendre l’application moins optimisée.

L’exemple suivant montre la définition d’une variable pour chaque attribut d’un objet, ce qui nécessite d’utiliser Set pour chaque propriété.

Set(varEmpName, Office365Users.MyProfile().DisplayName);
Set(varEmpCity, Office365Users.MyProfile().City);
Set(varEmpPhone, Office365Users.MyProfile().BusinessPhones);
Set(varEmpUPN, Office365Users.MyProfile().UserPrincipalName);
Set(varEmpMgrName, Office365Users.ManagerV2(varEmpUPN).DisplayName);

Une approche plus optimisée consiste à utiliser la propriété lorsque vous en avez besoin :

Set(varEmployee, Office365Users.MyProfile())
"Welcome " & varEmployee.DisplayName

Utilisez les variables de contexte et les variables globales à bon escient. Si la portée d’une variable s’étend au-delà d’un seul écran, envisagez d’utiliser des variables globales au lieu de variables de contexte.

Un trop grand nombre de variables inutilisées contribue à une utilisation accrue de la mémoire et à une initialisation légèrement plus lente de l’application. En effet, des ressources sont allouées à ces variables même si elles ne sont pas activement utilisées. Un trop grand nombre de variables inutilisées peut également aboutir à une complexité globale de la logique de l’application. Bien que l’impact des variables inutilisées ne soit pas grave, il est recommandé de maintenir une Power App propre et bien organisée pour garantir des performances optimales et une facilité de développement.

Optimiser les collections

Les collections sont des structures de stockage de données temporaires qui peuvent être utilisées pour stocker et manipuler des données dans une application Power Apps. Cependant, la limite est mince quant au moment où les collections peuvent entraîner une surcharge de performances. Par conséquent, limitez votre utilisation des collections. Essayez de les utiliser uniquement lorsqu’elles sont nécessaires.

// Use this pattern
ClearCollect(colErrors, {Text: gblErrorText, Code: gblErrorCode});

// Do not use this pattern
Clear(colErrors);
Collect(colErrors, {Text: gblErrorText, Code: gblErrorCode});

Pour compter les enregistrements dans une collection locale, utilisez CountIf au lieu de Count(Filter()).

Tenez compte de ces conseils lorsque vous utilisez des collections :

Limitez la taille et le nombre de collections. Étant donné que les collections sont locales à l’application, elles sont stockées dans la mémoire de l’appareil mobile. Plus les collections contiennent de données ou plus le nombre de collections est élevé, moins les performances sont bonnes. Utilisez la fonction ShowColumns pour obtenir uniquement les colonnes spécifiques. Ajoutez la fonction Filter pour obtenir uniquement les données pertinentes.

L’exemple de fonction suivant renvoie le jeu de données complet.

ClearCollect(colDemoAccount, Accounts);

Comparez au code ci-dessous qui ne va renvoyer que des enregistrements et des colonnes spécifiques :

ClearCollect(colAcc,
              ShowColumns(
                Filter(Accounts, !IsBlank('Address 1: City')),
                "name","address1_city"))

L’exemple de code renvoie ce jeu de données :

Définissez une fréquence d’actualisation de la source de données. Si vous ajoutez de nouveaux enregistrements à la collection, vous devez l’actualiser ou effectuer une collecte pour insérer les enregistrements nouveaux ou modifiés dans la collection. Si votre source de données est mise à jour par plusieurs utilisateurs, vous devez actualiser la collection pour obtenir les enregistrements nouveaux ou modifiés. Plus d’appels d’actualisation signifient plus d’interaction avec le serveur.

Mettre en cache les données dans les collections et les variables

Une collection, essentiellement une variable de table, se distingue par le fait qu’elle stocke des lignes et des colonnes de données plutôt qu’un seul élément de données. Leur utilité réside dans deux objectifs principaux : premièrement, pour agréger les données avant de les transmettre à la source de données, et deuxièmement, pour mettre les informations en cache, éliminant ainsi la nécessité de requêtes fréquentes à la source de données. À mesure que les collections s’alignent sur la structure tabulaire de la source de données et de Power Apps, elles offrent un moyen efficace d’interagir avec les données, même dans des scénarios hors ligne.

// Clear the contents of EmployeeCollection, it already contains data
ClearCollect(
    colEmployee,
    {
        Id: "1",
        Name: "John",
        Department: "IT"
    },
    {
        Id: "2",
        Name: "Nestor",
        Department: "IT"
    }
)

Supprimer les variables et les médias inutilisés

Même si les médias et les variables inutilisés ne peuvent pas avoir d’impact drastique sur les performances de l’application, il est important de nettoyer votre application en supprimant les médias ou les variables inutilisés.

• Les fichiers multimédias inutilisés contribuent à l’augmentation globale de la taille de l’application. Cela peut entraîner des temps de chargement plus lents de l’application.

• Les variables inutilisées contribuent à une utilisation accrue de la mémoire et à une initialisation légèrement plus lente de l’application. En effet, des ressources sont allouées à ces variables même si elles ne sont pas activement utilisées. De plus, un trop grand nombre de variables inutilisées peut aboutir à une complexité globale de la logique de l’application.

• Utilisez le vérificateur d’applications pour examiner les médias et les variables inutilisés.

Optimiser les écrans et les contrôles

Évitez les contrôles de référence croisée

Les contrôles qui référencent des contrôles sur d’autres écrans peuvent ralentir le chargement de l’application et la navigation. Cela risque de forcer l’application à charger immédiatement les autres écrans, plutôt que d’attendre que l’utilisateur accède à cet écran. Pour résoudre ce problème, utilisez plutôt des variables, des collections et un contexte de navigation pour partager l’état sur plusieurs écrans.

Le vérificateur d’applications Power Apps dans le studio de création affiche les contrôles à référence croisée. Consultez régulièrement le vérificateur d’applications pour résoudre ce problème.

Voici un exemple de contrôles à référence croisée. Dans l’image ci-dessous, les contrôles Galerie 1 sont référencés dans l’écran 2, contrôle Étiquette 2.

Si vous référencez un contrôle du premier écran de l’application dans le deuxième écran, les performances ne seront pas affectées car le premier écran a déjà été chargé et cela peut en réalité être une bonne chose car l’application est déclarative au lieu d’utiliser des variables.

Si vous référencez des contrôles qui n’ont pas encore été chargés, comme le premier écran référençant un contrôle nommé Label 3 à partir de l’écran 3, l’écran devra être chargé en mémoire.

Activer DelayOutput pour les contrôles de texte

Lorsque le paramètre Différer la sortie est défini sur true, l’entrée utilisateur est enregistrée après une demi-seconde. Il est utile pour retarder les opérations coûteuses jusqu’à ce que l’utilisateur termine d’entrer du texte, par exemple, pour filtrer lorsque l’entrée est utilisée dans d’autres formules.

Par exemple, pour une galerie dont les éléments sont filtrés en fonction de la saisie dans le contrôle TextInput :

• Avec DelayOutput défini sur false, qui est la valeur par défaut, la galerie est filtrée dès qu’un texte est saisi. Si une galerie contient beaucoup d’éléments, le rechargement immédiat de la galerie avec les modifications ralentit les performances ; il serait plus avantageux d’attendre un peu. Ceci est pratique lorsque vous utilisez TextInput pour une chaîne de recherche (voir Rechercher ou les nouvelles fonctions StartsWith).

• Avec DelayOutput défini sur true, il y a un deuxième délai avant que les modifications soient détectées. Cela vous donne le temps de finir de saisir ce que vous voulez. Le délai fonctionne bien lorsqu’il est utilisé pour aider la propriété TextInput.OnChange. Si des actions sont liées à des modifications, vous ne souhaitez pas qu’elles soient déclenchées jusqu’à ce que tout ce que vous souhaitez soit saisi dans le champ.

Délégation et traitement côté serveur

Délégation

La délégation dans Power Apps est un concept qui fait référence à la capacité de l’application à décharger certaines opérations dans la source de données sous-jacente plutôt que de traiter les opérations dans Power Apps lui-même. En utilisant la délégation dans Power Apps, les développeurs peuvent créer des applications plus efficaces et évolutives qui fonctionnent bien même dans des scénarios impliquant de grands jeux de données. Il est important de connaître les limitations de la délégation pour des sources de données et des opérations spécifiques, et de concevoir des applications en conséquence pour obtenir des performances optimales.

![NOTE] Toutes les fonctions ne sont pas délégables. Reportez-vous à Comprendre la délégation pour en savoir plus sur la délégation.

La délégation présente plusieurs avantages tels que l’optimisation des requêtes et ajoute la prise en charge pour les grands jeux de données. De plus, si les données sources sont modifiées fréquemment, la délégation permet de maintenir les données à jour.

Réduire les appels d’API à la source de données

Parfois, il peut être pratique de simplement suivre des pratiques de codage telles que la création de collections en effectuant des jointures dans l’application canevas. Reportez-vous au code ci-dessous :

Dans cet exemple, il y a deux tables, Chauffeurs et Camions. Le développeur écrit le code pour créer une collection de détails sur les chauffeurs et les camions et, pour chaque camion, il appelle les chauffeurs qui possèdent les camions.

// Bad code
ClearCollect(vartruckdata, AddColumns('Truck Details',
    "CITY",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],City),
        "FIRSTNAME",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],'Driver First Name'),
    "LASTNAME",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],'Driver Last Name'),
        "STATE",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],State)));

L’exécution de ces opérations de jointure à partir de l’application canevas peut générer de nombreux appels à la source de données, entraînant des temps de chargement très lents.

Une meilleure approche est la suivante :

// Good code
Set(
    varTruckData,
    LookUp(
        Drivers,
        'Dummy ID' = ThisRecord.'Dummy ID',
        'Driver First Name'
    ) & LookUp(
        Drivers,
        'Dummy ID' = ThisRecord.'Dummy ID',
        'Driver Last Name'
        )
);

Set(
    varTruckData,
    With(
        {
            vDriver: LookUp(
                Drivers,
                'Dummy ID' = ThisRecord.'Dummy ID'
            )
        },
        vDriver.'Driver First Name' & vDriver.'Driver Last Name'
    )
)

Dans le scénario en temps réel, il est possible de réduire les temps de chargement de 5 minutes à moins de 10 secondes en corrigeant simplement les données au niveau de la source de données.

Traitement côté serveur

Différentes sources de données telles que SQL et Dataverse vous permettent de déléguer le traitement des données, comme les filtres et les recherches dans la source de données. Dans SQL Server, les utilisateurs peuvent créer des vues dont le contenu est défini par une requête. De même, avec Dataverse, les utilisateurs peuvent créer des plug-ins low-code pour écrire une logique de traitement des données côté serveur et obtenir uniquement les résultats finaux dans les applications canevas.

La délégation du traitement des données au serveur peut améliorer les performances globales, réduire le code côté client et faciliter la maintenance.

En savoir plus sur les plug-ins dans Dataverse.

Optimiser les modèles de données de requête

Utiliser la sélection explicite de colonnes

La fonctionnalité de sélection explicite de colonne (ECS) est activée par défaut pour toutes les nouvelles applications. Si elle n’est pas activée pour votre application, vous devez l’activer. ECS réduit automatiquement le nombre de colonnes récupérées à celles utilisées dans l’application. Si ECS n’est pas activé, vous récupérez peut-être plus de données que nécessaire, ce qui peut affecter les performances. Parfois, lorsqu’une application extrait des données via des collections, la lignée ou la source d’origine d’une colonne peut être perdue. Nous ne savons pas s’il est utilisé et nous le supprimons en utilisant ECS. Généralement, vous pouvez forcer ECS à fonctionner pour une colonne manquante en utilisant l’expression PowerFx ShowColumns après une référence de collection ou en l’utilisant dans un contrôle.

Éviter d’appeler Power Automate pour remplir une collection

Une pratique courante consiste à utiliser Power Automate pour extraire et remplir des collections dans Power Apps. Bien que cette approche soit valable, il existe des situations où elle pourrait ne pas constituer le choix le plus efficace. L’appel de Power Automate s’accompagne d’une surcharge de la latence réseau et ajoute un coût de performances de 0,6 seconde pour instancier le flux Power Automate.

L’utilisation excessive de flux Power Automate peut également entraîner des limites d’exécution et une limitation. Par conséquent, évaluez toujours les compromis entre la latence du réseau et le coût des performances.

Éliminer le problème N+1

Le problème N+1 est un problème courant dans les requêtes de base de données où, au lieu d’extraire toutes les données requises dans une seule requête, plusieurs requêtes supplémentaires sont créées pour récupérer les données associées. Cela peut entraîner des problèmes de performances, car chaque requête supplémentaire génère une surcharge.

Un appel simple comme celui-ci pour charger une collection peut générer N+1 appels à la source de données.

ClearCollect(MyCollection, OrdersList,
    {
        LookUp(CustomersList,CustomerID = OrdersList[@CustomerID])
    }
)

Dans le contexte des applications canevas et des galeries, le problème N+1 peut survenir lorsque vous utilisez des sources de données et des galeries qui affichent des enregistrements associés. Le problème se produit généralement lorsque davantage de requêtes sont effectuées pour chaque élément affiché dans la galerie, ce qui entraîne un goulot d’étranglement des performances.

Utilisez Afficher les objets dans SQL Server pour éviter le problème de requête N+1, ou modifiez l’interface utilisateur pour éviter de déclencher le scénario N+1.

Dataverse extrait automatiquement les données requises des tables associées et vous pouvez sélectionner les colonnes des tables associées.

ThisItem.Account.'Account Name'

Si la taille de RelatedDataSource est petite (<500 enregistrements), vous pouvez la mettre en cache dans une collection et utiliser la collection pour piloter le scénario de requête de recherche (N+1).

Limiter la taille du package

Même si Power Apps contribue à optimiser le chargement des applications, vous pouvez prendre des mesures pour réduire l’empreinte de vos applications. Une empreinte réduite est particulièrement importante pour les utilisateurs d’appareils plus anciens ou pour les utilisateurs résidant dans des régions où la latence est plus élevée ou la bande passante réduite.

• Évaluez les médias intégrés dans votre application. Si quelque chose n’est pas utilisé, supprimez-le.

• Les images intégrées sont peut-être trop volumineuses. Au lieu de fichiers PNG, voyez si vous pouvez utiliser des images SVG. Toutefois, soyez prudent lorsque vous utilisez du texte dans des images SVG, car la police utilisée devra être installée sur le client. Une solution de contournement efficace lorsque vous devez afficher du texte consiste à superposer une étiquette de texte sur une image.

• Évaluez si la résolution est appropriée pour le facteur de forme. Il n’est pas nécessaire que la résolution pour une application mobile soit aussi élevée que celle pour une application de bureau. Expérimentez pour obtenir le bon équilibre entre la qualité et la taille d’image.

• Si des écrans sont inutilisés, supprimez-les. Veillez à ne pas supprimer les écrans masqués que seuls les créateurs ou les administrateurs d’applications utilisent.

• Évaluez si vous essayez de regrouper trop de flux de travail dans une seule application. Par exemple, avez-vous à la fois des écrans d’administrateur et des écrans de client dans la même application ? Si tel est le cas, envisagez de les diviser en applications individuelles. Cette approche permettra également à plusieurs personnes de travailler plus facilement sur les applications en même temps et limitera le « rayon d’explosion » (nombre de tests) lorsque les modifications de l’application nécessitent une réussite complète du test.

Optimiser ForAll

La fonction ForAll dans Power Apps est utilisée pour itérer dans une table d’enregistrements et appliquer une formule ou un ensemble de formules à chaque enregistrement. Bien que la fonction elle-même soit polyvalente, une mauvaise utilisation de la fonction ForAll peut rapidement rendre votre application moins performante.

La fonction ForAll est une fonction séquentielle singulière au lieu d’une fonction simultanée. Par conséquent, elle examine un seul enregistrement à la fois, obtient le résultat, puis passe au suivant jusqu’à ce qu’elle parcoure tous les enregistrements dans sa portée.

Évitez d’imbriquer ForAll à tout prix. Cela peut générer des itérations exponentielles et avoir un impact significatif sur les performances.

ClearCollect(FollowUpMeetingAttendees.ForAll(ForAll(Distinct(AttendeesList.EmailAddress.Address).Lookup(Attendees))))

Mises à jour par lots de la base de données

ForAll + Patch peut être une approche pour mettre à jour par lots la base de données. Toutefois, soyez prudent dans l’utilisation de l’ordre de For All et Patch.

La fonction suivante :

Patch(SampleFoodSalesData, ForAll(colSampleFoodSales,
    {
        demoName:"fromCanvas2"
    })
);

A de meilleures performances que :

ForAll(colSampleFoodSales, Patch(SampleFoodSalesData,
    {
        demoName:"test"
    })
);

Étape suivante

Directives de gestion des erreurs