Meilleures pratiques

Pour vous assurer que vos automatisations codées sont efficaces, maintenables et évolutives, vous devez suivre leurs bonnes pratiques. Cette section fournit un aperçu des bonnes pratiques à retenir lorsque vous vous lancez dans l’exploitation du code pour créer des solutions d’automatisation. L'adoption de ces bonnes pratiques vous aidera à concevoir des automatisations codées, en particulier lors de la structuration de votre code, de l'implémentation de stratégies de gestion des erreurs ou de la création de composants réutilisables.

Parallélisme

Le parallélisme améliore les performances et son implémentation dans les automatisations codées est simplifiée. Une boucle Pour chaque (For Each= peut augmenter la vitesse d’exécution d’une automatisation.

Classes imbriquées

Les automatisations codées (fichiers CS) ne prennent pas en charge l’utilisation ou l’invocation de variables ou d’arguments de classes imbriquées dans des automatisations low-code (fichiers XAML). Si vous essayez d’invoquer ce type d’arguments à l’aide d’une activité Appeler le fichier de flux de travail (Invoke Workflow File) ou de créer de tels arguments dans des fichiers XAML, vous recevrez des erreurs. Nous vous recommandons d’utiliser des variables et des arguments des classes imbriquées uniquement dans d’autres fichiers CS.

Héritage de workflow codé

L'héritage de workflow codé favorise la réutilisation et la modularité du code, vous permettant de créer une hiérarchie de classes où les classes enfants héritent et étendent les fonctionnalités des classes parentes. Cette hiérarchie d'héritage facilite l'organisation du code et évite de dupliquer les fonctionnalités communes à travers plusieurs classes. En outre, cela simplifie la maintenance et les mises à jour, car les modifications apportées à la classe parente sont automatiquement transmises à ses classes enfants, réduisant ainsi les risques d'introduire des bogues ou des incohérences.

Voyons comment fonctionne l'héritage à l'aide de trois classes : CodedWorkflow, ParentFile (une classe intermédiaire qui hérite de CodedWorkflow et contient une méthode personnalisée) et MyCustomWorkflow avec AnotherCustomWorkflow (classes dérivées qui héritent de ParentFile) . Le tableau ci-dessous montre comment fonctionne l'héritage entre ces classes et ces fichiers :

Automatisation codée Description Code

Automatisation codée	Description	Code
`CodedWorkflow` (read-only partial class)	Cette classe sert de base à tous les workflows codés. Elle contient des méthodes et des propriétés essentielles communes à tous les workflows, héritées de la classe `CodedWorkflowBase`. Dans cet exemple, il s'agit de la classe dont tous les autres workflows hériteront au final. Attention : le fichier dont les autres workflows héritent doit également hériter des classes `CodedWorkflow` et implicitement des classes `CodedWorkflowBase`. Cela garantit que tous les workflows héritent des fonctions essentielles et fonctionnent comme prévu.	`public partial class CodedWorkflow : CodedWorkflowBase { public CodedWorkflow() { //... } }`public partial class CodedWorkflow : CodedWorkflowBase { public CodedWorkflow() { //... } }
`ParentFile` (code source file containing an intermediate class and a custom method)	Cette classe hérite de `CodedWorkflow` et ajoute des méthodes et des fonctionnalités personnalisées. Dans cet exemple, elle inclut une méthode personnalisée appelée `CustomMethod`, qui effectue des actions spécifiques, telles que le démarrage d'une tâche dans Orchestrator.	`public class ParentFile : CodedWorkflow { public void CustomMethod(string processName, string folderPath, StartProcessDtoJobPriority jobPriority, bool resumeOnSameContext, out string jobId) { // Enter your custom code here. // For example, use the StartJob API inside this custom method. jobId = system.StartJob(processName, folderPath, jobPriority, resumeOnSameContext); } }`public class ParentFile : CodedWorkflow { public void CustomMethod(string processName, string folderPath, StartProcessDtoJobPriority jobPriority, bool resumeOnSameContext, out string jobId) { // Enter your custom code here. // For example, use the StartJob API inside this custom method. jobId = system.StartJob(processName, folderPath, jobPriority, resumeOnSameContext); } }
`MyCustomWorkflow` and `AnotherCustomWorkflow` (coded workflows that inherit the code source file)	Ces classes héritent de `ParentFile` et personnalisent davantage le workflow en remplaçant des méthodes ou en fournissant différentes valeurs de paramètre. Dans cet exemple, nous avons `MyCustomWorkflow` et `AnotherCustomWorkflow`, les deux héritant de `ParentFile`.	`public class MyCustomWorkflow : ParentFile { [Workflow] public void Execute() { // You can now call CustomMethod from the base class. string processName = "YourProcessName"; string folderPath = "YourFolderPath"; StartProcessDtoJobPriority jobPriority = StartProcessDtoJobPriority.Normal; bool resumeOnSameContext = false; string jobId; // Call the custom method from the base class. CustomMethod(processName, folderPath, jobPriority, resumeOnSameContext, out jobId); } }`public class MyCustomWorkflow : ParentFile { [Workflow] public void Execute() { // You can now call CustomMethod from the base class. string processName = "YourProcessName"; string folderPath = "YourFolderPath"; StartProcessDtoJobPriority jobPriority = StartProcessDtoJobPriority.Normal; bool resumeOnSameContext = false; string jobId; // Call the custom method from the base class. CustomMethod(processName, folderPath, jobPriority, resumeOnSameContext, out jobId); } }

CodedWorkflow (read-only partial class)

Cette classe sert de base à tous les workflows codés. Elle contient des méthodes et des propriétés essentielles communes à tous les workflows, héritées de la classe CodedWorkflowBase. Dans cet exemple, il s'agit de la classe dont tous les autres workflows hériteront au final.

Attention : le fichier dont les autres workflows héritent doit également hériter des classes CodedWorkflow et implicitement des classes CodedWorkflowBase. Cela garantit que tous les workflows héritent des fonctions essentielles et fonctionnent comme prévu.

public partial class CodedWorkflow : CodedWorkflowBase
    {
        public CodedWorkflow()
        {
         //...

    }
}public partial class CodedWorkflow : CodedWorkflowBase
    {
        public CodedWorkflow()
        {
         //...

    }
}

ParentFile (code source file containing an intermediate class and a custom method)

Cette classe hérite de CodedWorkflow et ajoute des méthodes et des fonctionnalités personnalisées. Dans cet exemple, elle inclut une méthode personnalisée appelée CustomMethod, qui effectue des actions spécifiques, telles que le démarrage d'une tâche dans Orchestrator.

public class ParentFile : CodedWorkflow
{
    public void CustomMethod(string processName, string folderPath, 
    StartProcessDtoJobPriority jobPriority, bool resumeOnSameContext, 
    out string jobId)
    {
        // Enter your custom code here.
        // For example, use the StartJob API inside this custom method.
        jobId = system.StartJob(processName, folderPath, jobPriority, resumeOnSameContext);
    }
}public class ParentFile : CodedWorkflow
{
    public void CustomMethod(string processName, string folderPath, 
    StartProcessDtoJobPriority jobPriority, bool resumeOnSameContext, 
    out string jobId)
    {
        // Enter your custom code here.
        // For example, use the StartJob API inside this custom method.
        jobId = system.StartJob(processName, folderPath, jobPriority, resumeOnSameContext);
    }
}

MyCustomWorkflow and AnotherCustomWorkflow (coded workflows that inherit the code source file)

Ces classes héritent de ParentFile et personnalisent davantage le workflow en remplaçant des méthodes ou en fournissant différentes valeurs de paramètre. Dans cet exemple, nous avons MyCustomWorkflow et AnotherCustomWorkflow, les deux héritant de ParentFile.

public class MyCustomWorkflow : ParentFile
    {
        [Workflow]
        public void Execute()
        {
            // You can now call CustomMethod from the base class.
            string processName = "YourProcessName";
            string folderPath = "YourFolderPath";
            StartProcessDtoJobPriority jobPriority = StartProcessDtoJobPriority.Normal;
            bool resumeOnSameContext = false;
            string jobId;

            // Call the custom method from the base class.
            CustomMethod(processName, folderPath, 
            jobPriority, resumeOnSameContext, out jobId);
        }
    }public class MyCustomWorkflow : ParentFile
    {
        [Workflow]
        public void Execute()
        {
            // You can now call CustomMethod from the base class.
            string processName = "YourProcessName";
            string folderPath = "YourFolderPath";
            StartProcessDtoJobPriority jobPriority = StartProcessDtoJobPriority.Normal;
            bool resumeOnSameContext = false;
            string jobId;

            // Call the custom method from the base class.
            CustomMethod(processName, folderPath, 
            jobPriority, resumeOnSameContext, out jobId);
        }
    }

En conclusion, du fait que ParentFile hérite de CodedWorkflow, toute classe qui hérite de ParentFile hérite indirectement des fonctionnalités et des méthodes de CodedWorkflow. En d'autres termes, MyCustomWorkflow et AnotherCustomWorkflow héritent de la fonctionnalité de base de la classe partielle CodedWorkflow jusqu'à la classe ParentFile, ainsi que d'autres classes personnalisées, telles que CustomMethod.

Enregistrement de services personnalisés

Pour améliorer vos automatisations codées, à l'aide d'une logique personnalisée, vous pouvez enregistrer des services personnalisés que vous utiliserez ultérieurement dans vos automatisations codées. Consultez Enregistrement de services personnalisés pour savoir comment enregistrer votre propre service personnalisé.

Contextes Avant (Before) et Après (After)

Dans les cas de test, les contextes Avant (Before) et Après (After) vous permettent d'exécuter certaines actions avant et après l'exécution du cas de test. Ces contextes sont couramment utilisés pour configurer et supprimer les ressources, effectuer la journalisation et gérer l’environnement de test. Consultez Contextes Avant (Before) et Après (After) pour découvrir comment les contextes se comportent et comment les implémenter.

Trucs et astuces

Concevez des automatisations codées efficaces et robustes à l'aide des conseils et astuces suivants. Cette collection d'informations vous aide à optimiser votre code, à éviter les erreurs et à maximiser les performances.

Nous vous recommandons de n'apporter aucune modification aux espaces de noms.
Stockez une action dans une classe et réutilisez-la dans votre projet pour éviter de dupliquer le code.
Vous pouvez supprimer les espaces de noms que vous avez importés au moment de la conception et qui ne sont plus nécessaires.
Si vous devez obtenir des données provenant de plusieurs applications, séparez les phases de l'automatisation codée afin de ne pas mélanger les données provenant de différentes sources.

Sommaire de la page