Mejores prácticas

Para garantizar que tus automatizaciones codificadas sean eficientes, mantenibles y escalables, debes seguir sus mejores prácticas. Esta sección proporciona una descripción general de las mejores prácticas clave que debes recordar al iniciar el viaje para aprovechar el código para crear soluciones de automatización. La adopción de estas mejores prácticas te ayudará a diseñar automatizaciones codificadas, específicamente al estructurar tu código, implementar estrategias de gestión de errores o crear componentes reutilizables.

Paralelismo

El paralelismo mejora el rendimiento, e implementarlo en las automatizaciones codificadas es más fácil. Un bucle Para cada puede aumentar la velocidad con la que se ejecuta una automatización.

Clases anidadas

Las automatizaciones codificadas (archivos CS) no admiten el uso o la invocación de variables o argumentos de clases anidadas dentro de automatizaciones de código bajo (archivos XAML). Si intentas invocar este tipo de argumentos utilizando una actividad Invocar archivo de flujo de trabajo, o crear tales argumentos en archivos XAML, recibirás errores. Recomendamos utilizar variables y argumentos de clases anidadas solo dentro de otros archivos CS.

Herencia del flujo de trabajo codificado

La herencia del flujo de trabajo codificado promueve la reutilización y la modularidad del código, lo que te permite crear una jerarquía de clases donde las clases secundarias heredan y amplían la funcionalidad de las clases principales. Esta jerarquía de herencia facilita la organización del código y evita la duplicación de la funcionalidad común en varias categorías. Además, simplifica el mantenimiento y las actualizaciones porque los cambios realizados en la clase principal se transmiten automáticamente a sus clases secundarias, lo que reduce las posibilidades de introducir errores o inconsistencias.

Demostremos cómo funciona la herencia utilizando tres categorías: CodedWorkflow, ParentFile (una clase intermedia que hereda CodedWorkflow y contiene un método personalizado), y MyCustomWorkflow junto con AnotherCustomWorkflow (clases derivadas que heredan ParentFile). La siguiente tabla muestra cómo funciona la herencia entre estas clases y archivos:

Automatización codificada Descripción Código

Automatización codificada	Descripción	Código
`CodedWorkflow` (read-only partial class)	Esta clase sirve como base para todos los flujos de trabajo codificados. Contiene métodos y propiedades esenciales que son comunes a todos los flujos de trabajo, heredados de la clase `CodedWorkflowBase`.En este ejemplo, es la clase de la que heredan finalmente todos los demás flujos de trabajo. Importante: el archivo que quieres que otros flujos de trabajo hereden también debe heredar `CodedWorkflow` e implícitamente las clases `CodedWorkflowBase`.Esto garantiza que todos los flujos de trabajo hereden las funciones esenciales y funcionen como se espera.	`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)	Esta clase hereda de `CodedWorkflow` y añade métodos y funcionalidades personalizados. En este ejemplo, incluye un método personalizado llamado `CustomMethod`, que realiza acciones específicas, como iniciar un trabajo en 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)	Estas clases heredan de `ParentFile` y personalizan aún más el flujo de trabajo anulando los métodos o proporcionando diferentes valores de los parámetros. En este ejemplo, tenemos `MyCustomWorkflow`y `AnotherCustomWorkflow`, ambos heredan `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)

Esta clase sirve como base para todos los flujos de trabajo codificados. Contiene métodos y propiedades esenciales que son comunes a todos los flujos de trabajo, heredados de la clase CodedWorkflowBase.En este ejemplo, es la clase de la que heredan finalmente todos los demás flujos de trabajo.

Importante: el archivo que quieres que otros flujos de trabajo hereden también debe heredar CodedWorkflow e implícitamente las clases CodedWorkflowBase.Esto garantiza que todos los flujos de trabajo hereden las funciones esenciales y funcionen como se espera.

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)

Esta clase hereda de CodedWorkflow y añade métodos y funcionalidades personalizados. En este ejemplo, incluye un método personalizado llamado CustomMethod, que realiza acciones específicas, como iniciar un trabajo en 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)

Estas clases heredan de ParentFile y personalizan aún más el flujo de trabajo anulando los métodos o proporcionando diferentes valores de los parámetros. En este ejemplo, tenemos MyCustomWorkflowy AnotherCustomWorkflow, ambos heredan 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 conclusión, porque ParentFile hereda de CodedWorkflow, cualquier clase que herede de ParentFile indirectamente hereda la funcionalidad y los métodos de CodedWorkflow. En otras palabras, tanto MyCustomWorkflow como AnotherCustomWorkflow heredan la funcionalidad básica de la clase parcial CodedWorkflow mediante el intermediario ParentFile, junto con otras clases personalizadas, como CustomMethod.

Registrar servicios personalizados

Para mejorar tus automatizaciones codificadas, utilizando la lógica personalizada, puedes registrar los servicios personalizados, que posteriormente usarás en tus automatizaciones codificadas. Consulta Registrar servicios personalizados para saber cómo registrar tu propio servicio personalizado.

Contextos Antes y Después

Dentro de los casos de prueba, los contextos Antes y Después te permiten ejecutar ciertas acciones antes y después de que se ejecute el caso de prueba. Estos contextos se utilizan comúnmente para configurar y eliminar recursos, realizar el registro y gestionar el entorno de prueba. Consulta Contextos antes y después para saber cómo se comportan los contextos y cómo implementarlos.

Consejos y trucos

Diseña automatizaciones codificadas eficientes y robustas utilizando los siguientes consejos y trucos. Esta colección de insights te ayuda a optimizar tu código, evitar errores y maximizar el rendimiento.

Te recomendamos que no realices ningún cambio en los espacios de nombres.
Almacena una acción dentro de una clase y reúsala en todo tu proyecto, para evitar duplicar código.
Puedes eliminar los espacios de nombres que importaste durante el tiempo de diseño, puesto que ya no son necesarios.
Si necesitas obtener datos de varias aplicaciones, separa las fases de la automatización codificada, para no mezclar los datos procedentes de varias fuentes.

En esta página