- Notes de publication
- Démarrage
- Paramétrage et configuration
- Projets d'automatisation
- À propos de la publication de projets d'automatisation
- Conception d'automatisations
- Gérer les package d’activités
- Configuration des paramètres du projet d'activité
- Signature de paquets
- Gouvernance
- Import des entités
- Modern Design Experience
- Lier un projet à une idée dans Automation Hub
- Utilisation du gestionnaire de données
- Dépendances
- Types de workflows
- Flux de contrôle
- Comparaison de fichiers
- Meilleures pratiques d'automatisation
- Intégration du contrôle de code source
- À propos du contrôle de version
- Gestion de projets à l'aide de TFS
- Gestion de projets à l'aide de SVN
- Diff de workflow
- Débogage
- Journalisation
- L'outil de diagnostic (Diagnostic Tool)
- Analyseur de workflow
- À propos de l'analyseur de workflow
- ST-NMG-001 - Convention d'affectation de noms des variables
- ST-NMG-002 - Convention d'affectation de noms des arguments
- ST-NMG-004 - Duplication du nom complet
- ST-NMG-005 - La variable remplace une autre
- ST-NMG-006 - La variable remplace l'argument
- ST-NMG-008 - Longueur de variable dépassée
- ST-NMG-009 - Ajouter un préfixe aux variables DataTable
- ST-NMG-011 - Ajouter un préfixe aux arguments Datatable
- ST-NMG-012 - Valeurs par défaut de l'argument
- ST-NMG-016 : longueur d'argument dépassée
- ST-NMG-017 : le nom de la classe correspond à l’espace de noms par défaut
- ST-DBP-002 - Nombre élevé d'arguments
- ST-DBP-003 - Bloc d'interception vide
- ST-DBP-007 - Plusieurs couches de l'organigramme
- ST-DPB-010 : plusieurs instances de [workflow] ou [cas de test]
- ST-DBP-020 - Propriétés de sortie non définies
- ST-DBP-021 - Délai d'expiration codé en dur
- ST-DBP-023 : Workflow vide
- ST-DBP-024 - Vérification de l’activité de persistance
- ST-DBP-025 - Condition préalable à la sérialisation des variables
- ST-DBP-026 - Utilisation de l’activité Délai
- ST-DBP-027 - Pratiques exemplaires de persistance
- ST-DBP-028 - Condition préalable à la sérialisation des arguments
- ST-MRD-002 - Valeurs par défaut des noms d'activités
- ST-MRD-004 - Activités inaccessibles
- ST-MRD-005 - Séquences redondantes
- ST-MRD-007 - Clauses If imbriquées
- ST-MRD-008 - Séquence vide
- ST-MRD-009 - Activités profondément imbriquées
- ST-MRD-011 - Utilisation de la ligne d'écriture
- ST-MRD-017 - Incomplet si (Incomplete If)
- ST-USG-005 - Arguments d'activité codée en dur
- ST-USG-009 - Variables inutilisées
- ST-USG-010 - Dépendances inutilisées
- ST-USG-014 - Restrictions sur les paquets (Package Restriction)
- ST-USG-020 - Nombre minimum de messages consignés
- ST-USG-024 - Non utilisé, sauvegardé pour plus tard (Unused Saved for Later)
- ST-USG-025 - Utilisation abusive de la valeur enregistrée (Saved Value Misuse)
- ST-USG-026 - Restrictions d'activité (Activity Restrictions)
- ST-USG-027 - Packages requis
- ST-USG-028 - Restreindre l'invocation des modèles de fichier
- ST-USG-027 - Balises requises
- ST-USG-034 – URL Automation Hub
- Variables
- Arguments
- Noms d'espace importés
- Automatisations codées
- Introduction
- Enregistrement de services personnalisés
- Contextes Avant (Before) et Après (After)
- Génération du code
- Génération de cas de test codé à partir de cas de test manuels
- Automatisation Attended basée sur déclencheur
- Enregistrement
- Éléments de l'interface utilisateur
- À propos des éléments d'interface utilisateur
- Propriétés des activités de l'interface utilisateur
- Exemple d'utilisation des méthodes de saisie
- Méthodes de sortie ou de capture de données d'écran
- Exemple d'utilisation de méthodes de sortie ou de capture de données d'écran
- Génération de tables à partir de données non structurées
- Capture relative de données
- Sélecteurs
- Réf. d’objets
- Capture de données
- Automatisation des images et des textes
- À propos de l'automatisation des images et des textes
- Activités liées à la souris et au clavier
- Exemple d'utilisation de l'automatisation de la souris et du clavier
- Les activités de type texte
- Exemple d'utilisation d'automatisation de texte
- Activités de type OCR
- Activités de type image
- Exemple d'utilisation de l'automatisation d'image et d'OCR
- Citrix Technologies Automation
- Automatisation de RDP
- Automatisation VMware Horizon
- Automatisation de Salesforce
- Automatisation SAP
- macOS UI Automation
- Outil ScreenScrapeJavaSupport
- Protocole Webdriver
- Extensions
- À propos des extensions
- Outil SetupExtensions
- UiPathRemoteRuntime.exe n'est pas en cours d'exécution dans la session distante
- UiPath Remote Runtime bloque la fermeture de la session Citrix
- UiPath Remote Runtime provoque une fuite de mémoire
- UiPath.UIAutomation.Activities package and UiPath Remote Runtime versions mismatch
- L'extension UiPath requise n'est pas installée sur la machine distante
- Paramètres de résolution d’écran
- Group Policies
- Impossible de communiquer avec le navigateur
- L’extension Chrome est automatiquement supprimée
- L'extension a peut-être été corrompue
- Vérification de l'installation et de l'activation de l'extension pour Chrome
- Vérifiez si ChromeNativeMessaging.exe est en cours d’exécution
- Vérifier si la variable ComSpec est correctement définie
- Activez l’accès aux URL de fichiers et au mode navigation privée
- Profils de navigateur multiples
- Group Policy conflict
- Problèmes connus spécifiques aux extensions MV3
- Liste des extensions pour Chrome
- Extension Chrome sur Mac
- Group Policies
- Impossible de communiquer avec le navigateur
- L’extension Edge est automatiquement supprimée
- L'extension a peut-être été corrompue
- Vérification si l'extension pour Microsoft Edge est installée et activée
- Vérifiez si ChromeNativeMessaging.exe est en cours d’exécution
- Vérifier si la variable ComSpec est correctement définie
- Activation de l'accès aux URL de fichiers et au mode navigation privée
- Profils de navigateur multiples
- Group Policy conflict
- Problèmes connus spécifiques aux extensions MV3
- Liste des extensions pour Edge
- Extension pour Safari
- Extension pour VMware Horizon
- Extension pour Amazon WorkSpaces
- Plug-in du gestionnaire de solution SAP
- Complément Excel
- Suite de tests - Studio
- Résolution des problèmes
- À propos de la résolution des problèmes
- Prise en charge et limitations de Microsoft App-V
- Résolution des problèmes rencontrés avec Internet Explorer x64
- Problèmes rencontrés avec Microsoft Office
- Identification des éléments d'IU dans PDF avec options d'accessibilité
- Réparation de la prise en charge d'Active Accessibility
- La validation des projets volumineux hérités depuis Windows prend plus de temps que prévu
Contextes Avant (Before) et Après (After)
BeforeRunContext
(configuration) : l'exécution Avant (Before) est utilisée pour effectuer des actions avant l'exécution principale du cas de test. Elle est souvent utilisée pour configurer l’état initial de l’environnement de test et préparer les ressources. Voici quelques cas d’utilisation courants du contexte Avant (Before) :- Initialisation des variables ou des données requises pour le test.
- Configuration de connexions à des systèmes ou bases de données externes.
- Journalisation du début de l'exécution du test.
- Ouverture d'applications ou de pages Web avec lesquelles le test interagit.
- Configurez des exceptions spécifiques avant d’exécuter le cas de test.
AfterRunContext
(nettoyage): l'exécution Après (After) est utilisée pour effectuer des actions une fois l'exécution principale du cas de test terminée. Elle est généralement utilisée pour nettoyer les ressources, finaliser les opérations et enregistrer les résultats du test. Les cas d'utilisation courants du contexte Après (After) sont les suivants :- Fermeture des applications ou pages Web utilisées pendant le test.
- Libération des ressources, telles que les connexions de base de données ou les ressources réseau.
- Capturez et imprimez les exceptions enregistrées dans le contexte Avant (Before) et l'exécution principale.
IBeforeAfterRun
adjacente à la classe principale, puis en implémentant votre propre logique personnalisée pour ces actions.
BeforeRunContext
, vous pouvez trouver
l'extrait de code
suivant :// Context of the run before the execution.
public class BeforeRunContext
{
// The relative path of the workflow.
public string RelativeFilePath { get; set; }
}
// Context of the run before the execution.
public class BeforeRunContext
{
// The relative path of the workflow.
public string RelativeFilePath { get; set; }
}
Ce contexte représente l'état avant l'exécution de l'automatisation. Il contient des informations sur le chemin relatif du workflow en cours d'exécution. Vous pouvez configurer des exceptions ici, en fonction de votre cas d'utilisation.
AfterRunContext
, vous pouvez trouver
l'extrait de code
suivant :// Context of the run after the execution.
public class AfterRunContext
{
// The relative path of the workflow.
public string RelativeFilePath { get; set; }
// The exception caught in execution if any.
public Exception Exception { get; set; }
}
// Context of the run after the execution.
public class AfterRunContext
{
// The relative path of the workflow.
public string RelativeFilePath { get; set; }
// The exception caught in execution if any.
public Exception Exception { get; set; }
}
Ce contexte représente l'état après l'exécution de l'automatisation. Il comprend des détails sur le chemin relatif du workflow exécuté et toute exception détectée avant et pendant l'exécution.
Before
et principale fonctionnent simultanément et capturent les exceptions qui apparaissent lors de l'exécution. Toutes les exceptions levées pendant ces phases sont capturées et stockées dans le AfterRunContext
, présentant une valeur nulle si aucune exception ne se produit.
Before
et principale exécutées, la méthode After
est exécutée. Si une exception est levée lors de l'exécution After
, l'exécution se termine et l'exception correspondante est générée.
Before
et After
, elles sont regroupées dans une AggregateException
.
Vous pouvez implémenter l'interface des exécutions Avant (Before) et Après (After) directement dans votre cas de test codé.
- Dans la classe publique où
se trouve votre cas de test codé, ajoutez l'interface
IBeforeAfterRun
. Ceci sera mis en évidence en rouge, indiquant les corrections potentielles.public class MyTest : CodedWorkflow, IBeforeAfterRun
public class MyTest : CodedWorkflow, IBeforeAfterRun - Sélectionnez Afficher les correctifs potentiels (Show potentiel correctifs) ou appuyez sur
Ctrl + .
et sélectionnez Implémenter l'interface (Implement interface).Cela générera une interface par défaut comme suit :public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); }
public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); } - Modifiez l'implémentation en fonction de vos besoins.
Dans l'exemple de code fourni, le contexte consigne un message avant l'exécution et recherche des exceptions par la suite.
public void After(AfterRunContext context) { if (context.Exception != null) { Log(context.Exception.Message); } } public void Before(BeforeRunContext context) { Log("this is before"); }
public void After(AfterRunContext context) { if (context.Exception != null) { Log(context.Exception.Message); } } public void Before(BeforeRunContext context) { Log("this is before"); }
.cs
de votre projet, en utilisant une classe partielle personnalisée.
- Créez un fichier de code source. C’est ici que vous allez implémentez l’interface des exécutions Avant (Before) et Après (After). Dans le cadre de notre exemple, nommez le fichier
TestCaseBase
.- Ajoutez l’interface
IBeforeAfterRun
à côté de la classe publique. Ceci sera mis en évidence en rouge, indiquant les corrections potentielles.Remarque : la classe partielle personnalisée (TestCaseBase
dans cet exemple) doit hériter de la classeCodedWorkflow
. Cela permet aux autres fichierscs
héritant de la classe partielle personnalisée de s’exécuter comme prévu.public class TestCaseBase : CodedWorkflow, IBeforeAfterRun
public class TestCaseBase : CodedWorkflow, IBeforeAfterRun - Sélectionnez Afficher les correctifs potentiels (Show potentiel correctifs) ou appuyez sur
Ctrl + .
et sélectionnez Implémenter l’interface (Implement interface).Cela générera une interface par défaut comme suit :public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); }
public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); } - Modifiez l'implémentation en fonction de vos besoins.
Dans l’exemple fourni, le contexte consigne un message avant l’exécution et recherche des exceptions par la suite.
public void After(AfterRunContext context) { if (context.Exception != null) { throw context.Exception; } else { Log("Test " + context.RelativeFilePath + " finished with no exception."); } } public void Before(BeforeRunContext context) { Log("Execution started for " + context.RelativeFilePath); }
public void After(AfterRunContext context) { if (context.Exception != null) { throw context.Exception; } else { Log("Test " + context.RelativeFilePath + " finished with no exception."); } } public void Before(BeforeRunContext context) { Log("Execution started for " + context.RelativeFilePath); }
Vous pourrez à présent utiliser cette classe partielle personnalisée pour utiliser la même interface d’exécutions Avant et Après uniquement pour les fichiers.cs
qui en héritent. - Ajoutez l’interface
- Créez une automatisation codée. Dans le cadre de cet exemple,
créez un cas de test codé nommé
TestCase
. Pour utiliser la même interface d’exécutions Avant et Après à partir de la classe partielle personnalisée, assurez-vous que le cas de test codé hérite de cette classe partielle.public class TestCase : TestCaseBase { [TestCase] public void Execute() { Log("Executing the test..."); }
public class TestCase : TestCaseBase { [TestCase] public void Execute() { Log("Executing the test..."); }
Execution started for file: TestCase.cs
[Info] IBeforeAfterRunExamples execution started
[Info] Execution started for TestCase.cs
[Info] Executing the test...
[Info] Test TestCase.cs finished with no exception.
[Info] IBeforeAfterRunExamples execution ended in: 00:00:00
Execution started for file: TestCase.cs
[Info] IBeforeAfterRunExamples execution started
[Info] Execution started for TestCase.cs
[Info] Executing the test...
[Info] Test TestCase.cs finished with no exception.
[Info] IBeforeAfterRunExamples execution ended in: 00:00:00
CodedWorkflow
, dont tout autre cas de test ou workflow codé à l’intérieur de votre projet peut hériter. Cette implémentation s’applique à tous les cas de test codés et à tous les workflows codés de votre projet.
- Créez un fichier source du code et donnez-lui un autre nom que
CodedWorkflow.cs
, sinon la classe partielle sera en conflit avec la classe en lecture seuleCodedWorkflow
existante. - Créez une classe partielle qui implémente l'interface personnalisée pour les contextes Avant (Before) et Après (After).
- Renommez la classe
CodedWorkflow
. Sinon, vous ne pourrez pas utiliser les services disponibles. - Assurez-vous que la classe de votre fichier source codé hérite de la classe
CodedWorkflowBase
. - Ajoutez l'espace de noms
UiPath.CodedWorkflows
au début de votre fichier source du code.using System; using System.Collections.Generic; using UiPath.CodedWorkflows;
using System; using System.Collections.Generic; using UiPath.CodedWorkflows; - Dans la classe de votre fichier source
du code, incluez
IBeforeAfterRun
.namespace TestAutomationProject1 { public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRun
namespace TestAutomationProject1 { public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRun - Pointez sur
IBeforeAfterRun
et sélectionnez Afficher les correctifs potentiels (Show potential fixes), ou sélectionnez cet élément et appuyez surCtrl + .
. - Sélectionnez Implémenter l'interface (Implement interface).
Cela crée l'implémentation par défaut ci-dessous :
public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); }
public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); } - Vous pouvez également personnaliser davantage l'interface en fonction de votre cas d'utilisation. Dans l'exemple de code ci-dessous, le contexte imprime un message avant l'exécution. Après l'exécution, il vérifie si une exception a été levée et l'imprime à nouveau.
public void After(AfterRunContext context) { if (context.Exception != null) { Log(context.Exception.Message); } } public void Before(BeforeRunContext context) { Log("this is before"); }
public void After(AfterRunContext context) { if (context.Exception != null) { Log(context.Exception.Message); } } public void Before(BeforeRunContext context) { Log("this is before"); }