Power Apps est idéal pour faire des applications personnalisées et sur mesure, encore plus pour interagir avec vos données. Encore faut-il savoir comment faire ! S’il est facile de créer un formulaire et d’utiliser SubmitForm() pour mettre à jour des données, le résultat est souvent visuellement décevant.
Pour un meilleur design, il est préférable de créer manuellement les entrées de données, et la fonction Patch devient donc essentielle.
En bref : la fonction Patch en une phrase
Patch crée ou modifie une ligne dans une source de données (liste SharePoint, table Dataverse, table SQL, collection) sans passer par un formulaire : Patch(Source, Ligne à modifier ou Defaults(Source), {Colonne: Valeur}). Elle renvoie la ligne écrite, ce qui permet de récupérer son identifiant.
Aide-mémoire : les formules Patch à copier
Exemples sur une liste « Employes », celle de l’application de gestion du personnel présentée plus bas :
| Besoin | Formule |
|---|---|
| Créer une ligne | Patch(Employes, Defaults(Employes), {Nom: "Durand", Service: "RH"}) |
| Créer une ligne et garder son identifiant | Set(varNouvel, Patch(Employes, Defaults(Employes), {Nom: "Durand"})); puis varNouvel.ID |
| Modifier une ligne précise | Patch(Employes, LookUp(Employes, ID = 12), {Service: "Finance"}) |
| Modifier la ligne choisie dans une galerie | Patch(Employes, Galerie1.Selected, {Statut: "Validé"}) |
| Modifier plusieurs lignes, une par une | ForAll(colModifs As m, Patch(Employes, LookUp(Employes, ID = m.ID), {Statut: m.Statut})) |
| Modifier plusieurs lignes en une fois | Patch(Employes, colModifs), la collection contenant la colonne ID |
| Fusionner deux enregistrements | Patch(varEmploye, varEquipe) |
Les formules sont écrites avec la virgule comme séparateur. Si votre Power Apps est réglé en français, remplacez les virgules par des points-virgules, et les points-virgules qui enchaînent deux formules par des doubles points-virgules.
Vers quelle source de données utiliser la fonction Patch
Tout d’abord, quelles sources de données sont compatibles avec cette fonction ? Pour faire simple : toutes.
Que ce soient les listes SharePoint, les collections, les tables Dataverse… même une table SQL server ! Tant que la source est présente dans l’onglet « données » de l’application, on peut utiliser Patch(). Certaines sources (comme SQL) sont cependant plus exigeantes sur les types de données, il faut donc rester attentif.
En dehors de ces questions de typage de la donnée, la source ne change rien à la syntaxe ni au fonctionnement de la fonction Patch().
Dans quels cas utiliser la fonction Patch ?
La fonction Patch() est utile dans 3 types de situation. Le premier est de créer une nouvelle ligne dans une source de données. Le deuxième usage est de mettre à jour les infos d’une ligne. Le troisième, moins répandu, permet de fusionner deux enregistrements en un seul.
Pour la suite, nous allons utiliser une application de gestion de personnel, qui nous permettra d’illustrer tous les cas d’usage.

On a ici une galerie qui prend une collection comme source, qu’on peut agrémenter avec un bouton « ajouter », ou modifier via les icônes de crayon.
Cas 1 : Créer une ligne
Pour le premier cas, le fonctionnement est extrêmement simple et assez intuitif. L’ajout de ligne a la syntaxe suivante :Patch(‘Source’, Defaults(‘Source’), {champ1 : valeur1, champ2 : valeur2, …})

Il n’y a pas trop de subtilité si ce n’est la fonction Defaults(), qui permet d’éviter les erreurs liées aux champs obligatoires qui n’auraient pas été renseignés. Avec cette fonction, ces champs obligatoires sont remplis a minima avec des valeurs par défaut (s’ils ne sont pas déjà renseignés dans le patch !).
Récupérer l’enregistrement créé
Patch renvoie la ligne qu’elle vient d’écrire, avec les colonnes calculées par la source, dont l’identifiant. Pour l’utiliser ensuite, stockez-la dans une variable :
Set(varNouvel, Patch(Employes, Defaults(Employes), {Nom: TextInput1.Text}));
Notify("Fiche n° " & varNouvel.ID & " créée", NotificationType.Success)
C’est la méthode à suivre pour créer une ligne puis ses lignes liées : une demande, puis ses articles, chacun rattaché à varNouvel.ID.
Cas 2 : Mettre à jour une ligne
Le deuxième cas concerne l’édition de ligne. Toujours dans notre petite application, un clic sur l’icône de crayon passe la ligne en mode édition, ce qui nous permet d’effectuer nos modifications. Une fois effectuées, il ne reste qu’à cliquer sur l’icone de sauvegarde pour enregistrer les changements. Je change ici mon rôle pour CEO (c’est mon article, je fais ce que je veux).

Là aussi, la subtilité se situe sur le deuxième argument. Dans presque toutes les situations, ce deuxième argument est la clé pour définir ce qu’on veut patch et comment. La syntaxe reste globalement la même :
Patch(‘Source’, Enregistrement, {champ1 : NouvelleValeur1, champ2 : NouvelleValeur2, …})

Ici, j’ai pris l’option simple de juste renseigner « ThisItem » dans le deuxième argument. Ça fonctionne très bien dans les collections, mais pour plus de sécurité on peut passer par un LookUp, pour s’assurer de bien cibler la bonne ligne.
On aura alors :

On se base alors sur l’id, qui est ici le seul champ que je ne peux pas modifier, et qui assure l’unicité de mes lignes. La syntaxe du LookUp revient à dire « récupère dans cette table l’enregistrement qui correspond à ce critère ».
Note importante : Si votre critère ne permet pas de cibler un seul enregistrement, la fonction LookUp ne renvoie que le premier cas qui correspond audit critère, selon l’ordre de tri par défaut dans votre source de données.
Cas 3 : Fusionner deux enregistrements
C’est un cas qui est moins fréquent, et avec lequel il faut être prudent. Le principe, c’est d’enrichir les données d’un enregistrement A avec celles d’un enregistrement B, sans que les 2 aient forcément les mêmes champs. Ça peut être très pratique dans des cas assez spécifiques où on cherche à fusionner les infos provenant de 2 tables, mais ça peut engendrer des chimères si ce n’est pas bien exécuté.
Assez parlé, voici comment ça fonctionne :
Patch({Enregistrement A},{Enregistrement B})
Plus besoin de préciser une source ou une méthode de Patch, car on cherche uniquement à fusionner deux enregistrements. Plus exactement, on cherche à ajouter des infos de l’enregistrement B dans l’enregistrement A. Dans notre application exemple, imaginons que je veux rassembler des infos d’un employé avec les infos de son équipe.

Je crée une variable _varselectemployee pour l’employé que je choisis (Totora, notre fidèle Chief Happiness Officer), une variable _varselectteam pour l’équipe correspondante, et je fusionne les deux dans une troisième variable avec la fonction Set(_varMerged,Patch(_varselectemployee,_varselectteam))
Si on regarde nos variables, on a bien fusionné comme il faut : les infos de l’équipe de direction se sont correctement ajoutées dans l’enregistrement de l’employé.

Mais que se passe-t-il si je fusionne 2 lignes qui n’ont rien à voir ?

On voit avec les données en bas que la fusion marche, mais la donnée finale est fausse vis-à-vis de l’employé.
Autre cas encore, si nos données ne correspondent pas entre les 2 enregistrements : Jusqu’ici j’ai pris des cas où il y avait au moins un champ en commun entre les deux variables. Mais si cette correspondance n’existe pas, le résultat peut devenir chaotique.
Changeons le nom de la propriété « equipe » pour l’appeler « Equipe », mais uniquement coté répertoire des équipes. La différence est subtile, mais si on refusionne les lignes Totora et sales, on obtient ceci :

Encore une fois, pas de message d’erreur, le patch fonctionne. Mais notre donnée en sortie n’est plus cohérente ! On se retrouve avec un enregistrement qui a deux infos contradictoires, pour une simple majuscule. Prudence, donc.
Patch() avec plusieurs lignes ?
Maintenant qu’on a vu les cas d’usage simple, passons aux choses sérieuses : Comment faire quand on a plusieurs lignes, voir plusieurs centaines de lignes à modifier ou créer ?
Imaginons que notre application est utilisée majoritairement hors ligne, et qu’on a besoin de synchroniser quand on retrouve la connexion.

Une solution instinctive est d’utiliser la fonction ForAll, pour itérer sur une collection et patcher chaque ligne. Le mécanisme est alors le même que dans nos patchs unitaires.
On a donc :

Cette solution peut toutefois s’avérer peu efficiente, dans le cas de très nombreuses lignes et/ou de très nombreuses colonnes. On en a déjà parlé ici, et la meilleure pratique serait de transmettre la tâche à un flux Power Automate.
Il y a une autre solution, moins intuitive car elle change un peu de syntaxe, mais beaucoup plus efficace : on peut patch une source de données avec une collection directement.

Vous serez d’accord pour dire que c’est plus simple, non ? Et en plus, c’est extrêmement plus rapide car on fait ici de la mise à jour en bloc (bulk update) : tout est pris en compte d’un coup.
Là où le ForAll(Patch()) peut prendre plusieurs secondes, cette syntaxe de patch unique durera 2 fois moins longtemps !


Voici le détail des fonctions utilisées pour calculer la durée de patch()

On pourrait même encore optimiser en ne prenant que les champs modifiés, ce qui creuserait encore l’écart. Et surtout, dans ce test il n’y a que 20 lignes. Imaginez avec des centaines d’enregistrements à synchroniser.
Attention toutefois ! Cette syntaxe de patch avec une collection directement ne marche que dans des cas bien précis ! Déjà, elle n’est compatible qu’avec SharePoint, Dataverse n’accepte pas ce type de patch.
Ensuite, il faut que votre colonne ID soit présente, et que les noms des champs modifiés de votre collection soient strictement les mêmes que ceux de votre liste source.
Et pour finir, cette méthode ne fonctionne que dans le cas des mises à jour de lignes. Pour le cas des créations, il faudra quand même passer par la méthode du ForAll(Patch()), ou par un flux Power Automate.
Colonnes SharePoint : choix, recherche, personne
La plupart des formules Patch qui échouent sur une liste SharePoint butent sur le format d’une colonne. Chaque type attend une structure précise :
| Type de colonne | Format attendu dans Patch |
|---|---|
| Texte, nombre, oui ou non | {Nom: TextInput1.Text, Salaire: Value(TextInput2.Text), Actif: true} |
| Date | {DateEntree: DatePicker1.SelectedDate} |
| Choix | {Service: {Value: "RH"}} |
| Choix multiples | {Competences: Table({Value: "Excel"}, {Value: "SQL"})} |
| Recherche (lookup) | {Equipe: {Id: 3, Value: "Direction"}} |
| Personne | {Responsable: {Claims: "i:0#.f|membership|" & User().Email, DisplayName: User().FullName, Email: User().Email, Department: "", JobTitle: "", Picture: ""}} |
Avec une liste déroulante, passez directement l’élément choisi quand il vient de la même source : {Service: ListeService.Selected}. Sur Dataverse, une colonne de recherche se renseigne avec la ligne liée elle-même : {Equipe: LookUp(Equipes, Nom = "Direction")}.
Gérer les erreurs de Patch
Sans précaution, un Patch qui échoue affiche un bandeau rouge peu compréhensible pour l’utilisateur. La fonction IfError permet de contrôler le message :
IfError(
Patch(Employes, Defaults(Employes), {Nom: TextInput1.Text}),
Notify("Enregistrement impossible : " & FirstError.Message, NotificationType.Error),
Notify("Fiche enregistrée", NotificationType.Success)
)
Le deuxième argument s’exécute en cas d’erreur, le troisième quand tout s’est bien passé. La fonction Errors(Employes) donne en plus le détail de la dernière erreur rencontrée sur la source, colonne par colonne. Les causes les plus fréquentes : une colonne obligatoire non renseignée, un format de colonne SharePoint incorrect, ou un utilisateur sans droit d’écriture sur la liste.
Patch, SubmitForm, Update : lequel choisir
| Fonction | À utiliser quand |
|---|---|
| SubmitForm | Vous utilisez un formulaire Power Apps relié à la source : validation et messages d’erreur sont gérés pour vous, mais la mise en page est contrainte. |
| Patch | Vous construisez vos propres écrans, modifiez quelques colonnes, écrivez dans plusieurs sources ou avez besoin de la ligne créée. |
| Update | Vous remplacez une ligne entière : les colonnes que vous ne fournissez pas sont vidées. |
| UpdateIf | Vous modifiez toutes les lignes qui remplissent une condition, par exemple passer au statut « Archivé » les demandes de plus d’un an. |
| Collect | Vous ajoutez des lignes, le plus souvent dans une collection locale. |
Pour les formulaires, voir notre guide du formulaire Power Apps.
En tout cas, vous voici maintenant expert du Patch ! Vous pouvez ranger vos Forms, et libérer votre imagination de leur design limité !
À lire aussi :
Questions fréquentes
Comment utiliser Patch dans Power Apps ?
Patch prend trois arguments : la source de données, la ligne à modifier (ou Defaults(Source) pour en créer une), et un enregistrement avec les colonnes à écrire. Exemple : Patch(Employes, Defaults(Employes), {Nom: "Durand"}) crée une ligne dans la liste Employes.
Comment récupérer l’identifiant d’un enregistrement créé avec Patch ?
Patch renvoie la ligne écrite. Stockez-la dans une variable avec Set(varNouvel, Patch(...)), puis utilisez varNouvel.ID dans la suite de la formule ou dans un autre écran.
Comment modifier plusieurs lignes avec Patch ?
Deux méthodes : ForAll avec un Patch par ligne, simple mais lent sur de gros volumes, ou un seul Patch qui reçoit une collection contenant la colonne ID, bien plus rapide. Pour des centaines de lignes, un flux Power Automate est souvent préférable.
Comment patcher une colonne de choix ou de personne SharePoint ?
Une colonne de choix attend un enregistrement {Value: "RH"}. Une colonne de personne attend un enregistrement avec Claims, DisplayName, Email, Department, JobTitle et Picture, où Claims vaut "i:0#.f|membership|" suivi de l’adresse de la personne.
Quelle différence entre Patch et SubmitForm ?
SubmitForm enregistre un formulaire Power Apps et gère la validation pour vous. Patch écrit directement dans la source depuis n’importe quel écran : plus de liberté de design, mais vous gérez vous-même les contrôles et les erreurs.
Pour aller plus loin : Microsoft Dataverse, les fonctionnalités avancées de Power Apps et la formation Power Apps de YoungData, certifiée Qualiopi.









