Optimisation du code

À mesure que les applications canevas évoluent pour répondre aux différents besoins de l’entreprise, il est essentiel de maintenir des performances optimales. Le traitement des données, la conception de l’interface utilisateur et les fonctionnalités de l’application nécessitent tous une approche minutieuse de l’optimisation du code.

Lorsque les applications canevas deviennent plus complexes, vous pouvez rencontrer des problèmes de récupération de données, de complexité des formules et de vitesse de rendu. L’équilibre entre des fonctionnalités puissantes et une interface utilisateur réactive signifie que vous avez besoin d’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 ou effectuer des actions, comme modifier des données ou utiliser une connexion. Utilisez With pour rendre les formules complexes plus faciles à lire 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 With. Il est préférable d’utiliser la fonction With que les variables de contexte ou globales, car elle est autonome, facile à comprendre et fonctionne dans n’importe quel contexte de formule déclarative. En savoir plus sur la fonction With.

Fonction Concurrent

La fonction Concurrent permet à plusieurs formules dans la même propriété d’être évaluées en même temps si elles ont un connecteur ou des appels Dataverse. Normalement, plusieurs formules sont évaluées en même temps lorsque vous les enchaînez à l’opérateur ; (point-virgule). Avec Concurrent, l’application évalue toutes les formules d’une propriété en même temps, même après avoir utilisé l’opérateur ;. Cette simultanéité signifie que les utilisateurs attendent moins longtemps pour les résultats. 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 qui n’est pas 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 vides ou des chaînes vides, la fonction retourne blank. Coalesce est 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 composé de caractères ordinaires, de modèles prédéfinis ou d’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.

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.

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.

Fonctions définies par l’utilisateur

Les fonctions définies par l’utilisateur dans le studio de création Power Apps permettent aux utilisateurs de créer leur propre fonction personnalisée.

Pour utiliser cette fonctionnalité, sous les paramètres de la version préliminaire, activez Fonction définie par l’utilisateur (FDU). La fonctionnalité en version préliminaire ne doit pas être utilisée en production, c’est pourquoi elle est désactivée par défaut, mais sera bientôt mise à la disposition générale.

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 sont les suivants : Booléen, Couleur, Date, DateHeure, Dynamique, GUID, Lien hypertexte, Texte et Heure

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

Optimiser les variables

Les variables définissent et fixent les valeurs locales et globales que vous utilisez dans l’ensemble de votre application. Bien qu’elles soient pratiques, l’utilisation d’un trop grand nombre de variables peut rendre votre application moins efficace.

L’exemple suivant montre comment définir 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 efficace consiste à n’utiliser la propriété que 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 va au-delà d’un seul écran, utilisez des variables globales au lieu des variables de contexte.

Un trop grand nombre de variables inutilisées augmente l’utilisation de la mémoire et peut ralentir l’initialisation de l’application. Des ressources sont allouées à ces variables même si vous ne les utilisez pas. Les variables inutilisées ajoutent également de la complexité à la logique de votre application. Bien que l’impact ne soit pas grave, il est recommandé de maintenir votre Power App propre et organisée pour obtenir de meilleures performances et faciliter le développement.

Optimiser les collections

Les collections sont des structures de stockage de données temporaires que vous utilisez pour stocker et manipuler des données dans une application Power Apps. Toutefois, les collections peuvent entraîner une surcharge de performances si vous les utilisez trop. Limitez votre utilisation des collections et ne les utilisez que lorsque cela est nécessaire.

// 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 à la place 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 de données contiennent de données, ou plus vous en utilisez, plus les performances sont mauvaises. Utilisez la fonction ShowColumns pour obtenir uniquement des 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 cela au code suivant, qui renvoie uniquement des enregistrements et des colonnes spécifiques :

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

Cet exemple renvoie le jeu de données suivant :

Définissez une fréquence d’actualisation de la source de données. Si vous ajoutez de nouveaux enregistrements à la collection, actualisez-la ou collectez-y pour obtenir les enregistrements nouveaux ou modifiés. Si plusieurs utilisateurs mettent à jour votre source de données, actualisez 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 est une variable de table qui stocke des lignes et des colonnes de données, et pas seulement un seul élément de données. Les collections sont utiles pour deux raisons principales : l’agrégation des données avant de les envoyer à la source de données et la mise en cache des informations pour éviter les requêtes fréquentes. Étant donné que les collections correspondent à la structure tabulaire de la source de données et de Power Apps, elles vous permettent d’interagir efficacement avec les données, même lorsque vous êtes hors connexion.

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

Bien que les médias et variables inutilisés n’aient pas nécessairement d’impact significatif sur les performances de l’application, il est important de nettoyer votre application en supprimant tous les médias ou variables inutilisés.

• Les fichiers multimédias inutilisés augmentent la taille de l’application, ce qui peut ralentir les temps de chargement de l’application.

• Les variables inutilisées augmentent l’utilisation de la mémoire et peuvent ralentir légèrement l’initialisation de l’application. Des ressources sont allouées à ces variables même si elles ne sont pas utilisées. Un trop grand nombre de variables inutilisées peut également rendre la logique de l’application plus complexe.

• 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 peut forcer l’application à charger les autres écrans immédiatement, plutôt que d’attendre que l’utilisateur accède à cet écran. Pour corriger ce problème, utilisez plutôt des variables, des collections et un contexte de navigation pour partager l’état sur les différents écrans.

Le vérificateur d’applications dans Power Apps Studio affiche les contrôles avec des références croisées. Consultez régulièrement le vérificateur d’application pour résoudre ce problème.

Voici un exemple de contrôles à référence croisée. Dans l’image ci-dessous, le contrôle Galerie 1 a une référence croisée 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, il n’y a pas d’impact sur les performances, car le premier écran est déjà chargé. Cela peut en fait être une bonne chose car l’application est déclarative au lieu d’utiliser des variables.

Si vous faites référence à des contrôles qui ne sont pas encore chargés, comme le premier écran faisant référence à un contrôle nommé Label 3 à partir de l’écran 3, l’application charge cet écran en mémoire.

Activer DelayOutput pour les contrôles de texte

Le paramètre DelayOutput, lorsqu’il est défini sur true, enregistre l’entrée utilisateur après une demi-seconde. Cela peut être utile pour retarder les opérations coûteuses jusqu’à ce que l’utilisateur termine d’entrer du texte, par exemple pour le filtrage 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 ce que l’utilisateur saisit dans le contrôle TextInput :

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

• Lorsque DelayOutput est défini sur true, il y a un court délai avant que les modifications ne soient détectées. Cela vous laisse le temps de finir de taper. Le délai fonctionne bien avec la propriété TextInput.OnChange. Si des actions sont liées à des modifications, elles ne doivent pas être déclenchées tant que vous n’avez pas fini de taper 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 sembler pratique de créer des collections en effectuant des jointures au sein de votre application canevas. Prenons un exemple :

Dans cet exemple, il y a deux tables : Chauffeurs et Camions. Le code crée une collection de conducteurs et de détails sur les camions, et pour chaque camion, il appelle le conducteur qui possède le camion.

// 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 d’une telle jointure dans l'application canevas peut générer de nombreux appels à la source de données, ce qui entraîne des temps de chargement 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 temps réel, vous pouvez réduire les temps de chargement de cinq minutes à moins de 10 secondes en fixant les données à la source.

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, à la source de données. Dans SQL Server, vous pouvez créer des vues définies par une requête. Dans Dataverse, vous pouvez créer des plug-ins low-code pour traiter les données sur le serveur et renvoyer uniquement les résultats finaux à votre application canevas.

Déléguer le traitement des données au serveur peut améliorer les performances, réduire le code côté client et faciliter la maintenance de votre application.

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 de colonne explicite (ECS) est activée par défaut pour toutes les nouvelles applications. S’il n’est pas activé pour votre application, activez-le. 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 risquez d’obtenir plus de données que nécessaire, ce qui peut affecter les performances. Parfois, lorsqu’une application obtient des données via des collections, la source d’origine d’une colonne peut être perdue. ECS supprime des colonnes s’il ne peut pas savoir qu’elles sont utilisées. Pour forcer ECS à conserver une colonne manquante, utilisez l’expression PowerFx ShowColumns après une référence de collection ou 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"
    })
);

Fonctionne mieux que :

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

Étape suivante