Capítulo 17: Ejecutar múltiples comandos en EPLAN

5 min de lectura

Parte II: Primeros pasos con EPLAN API - Sección 6: CommandLineInterpreter básico - Nivel: Principiante

Objetivos de aprendizaje

Al finalizar este capítulo serás capaz de:

Ejecutar múltiples comandos de EPLAN en secuencia
Crear workflows básicos con CommandLineInterpreter
Entender el orden de ejecución de comandos
Manejar errores en workflows de múltiples comandos
Combinar comandos para automatizar tareas repetitivas

Requisitos previos

Antes de comenzar este capítulo debes:

Haber completado el Capítulo 16 (ejecutar comando simple)
Entender cómo crear una instancia de CommandLineInterpreter
Conocer el método Execute() y su valor de retorno
Saber usar try-catch para manejo de errores

Introducción

En el capítulo anterior aprendiste a ejecutar un comando simple con CommandLineInterpreter. Pero en el mundo real, raramente ejecutarás solo un comando.

Imagina que quieres automatizar tu proceso diario de trabajo:

Generar conexiones y numeración del proyecto
Abrir la ventana de reportes
Verificar el proyecto en busca de errores

¿Tendrías que ejecutar el script tres veces, una por cada comando?

No. Puedes ejecutar múltiples comandos en un mismo script, creando lo que llamamos workflows (flujos de trabajo).

1. Script básico con múltiples comandos

1.1 Ejemplo del script oficial

Este ejemplo está basado directamente en EPLAN-Scripting-4.0/02_RunActions/02_MultipleActions.cs:

using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;

public class MultiplesComandos
{
    [Start]
    public void Function()
    {
        CommandLineInterpreter cli = new CommandLineInterpreter();

        cli.Execute("generate");
        cli.Execute("compress");
        cli.Execute("check");
    }
}

1.2 Análisis línea por línea

Líneas 9-10: Crear CLI una sola vez

CommandLineInterpreter cli = new CommandLineInterpreter();

Creas el intérprete una sola vez y lo reutilizas para todos los comandos.

Líneas 12-14: Ejecutar comandos en secuencia

cli.Execute("generate");   // Comando 1
cli.Execute("compress");   // Comando 2
cli.Execute("check");      // Comando 3

Los comandos se ejecutan en orden, uno después del otro.

1.3 ¿Qué hace este script?

Al ejecutar este script:

Primer comando: Genera conexiones y numeración
Segundo comando: Comprime el proyecto (optimiza almacenamiento interno)
Tercer comando: Verifica el proyecto en busca de errores

Todo esto ocurre automáticamente, sin intervención del usuario.

2. Orden de ejecución

2.1 Ejecución secuencial

Los comandos se ejecutan en el orden en que aparecen:

CommandLineInterpreter cli = new CommandLineInterpreter();

cli.Execute("comando1");  // Se ejecuta PRIMERO
cli.Execute("comando2");  // Se ejecuta SEGUNDO
cli.Execute("comando3");  // Se ejecuta TERCERO

Importante: Cada comando espera a que el anterior termine antes de ejecutarse.

2.2 Ejemplo práctico: Workflow de documentación

using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;

public class WorkflowDocumentacion
{
    [Start]
    public void Function()
    {
        CommandLineInterpreter cli = new CommandLineInterpreter();

        // Paso 1: Generar conexiones y numeración
        cli.Execute("generate");

        // Paso 2: Comprimir proyecto
        cli.Execute("compress");

        // Paso 3: Verificar proyecto
        cli.Execute("check");
    }
}

Este script crea un workflow que:

Genera conexiones y numeración automáticamente
Comprime el proyecto para optimizar almacenamiento
Verifica el proyecto en busca de errores

3. Manejo de errores en workflows

3.1 Problema: Un comando falla

¿Qué pasa si el segundo comando falla? Por defecto, el script continúa ejecutando los siguientes comandos.

3.2 Validar cada comando individualmente

using System;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;
using System.Windows.Forms;

public class WorkflowConValidacion
{
    [Start]
    public void Function()
    {
        try
        {
            CommandLineInterpreter cli = new CommandLineInterpreter();

            // Comando 1: Generar conexiones
            bool resultado1 = cli.Execute("generate");
            if (!resultado1)
            {
                MessageBox.Show("Error al generar");
                return;  // Detener ejecución
            }

            // Comando 2: Comprimir proyecto
            bool resultado2 = cli.Execute("compress");
            if (!resultado2)
            {
                MessageBox.Show("Error al comprimir proyecto");
                return;  // Detener ejecución
            }

            // Comando 3: Verificar proyecto
            bool resultado3 = cli.Execute("check");
            if (!resultado3)
            {
                MessageBox.Show("Error al verificar proyecto");
                return;  // Detener ejecución
            }

            MessageBox.Show("Workflow completado exitosamente");
        }
        catch (Exception ex)
        {
            MessageBox.Show("Error: " + ex.Message);
        }
    }
}

Ventaja: Si un comando falla, detienes el workflow inmediatamente.

3.3 Continuar aunque fallen comandos

A veces quieres ejecutar todos los comandos aunque alguno falle:

using System;
using System.Text;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;
using System.Windows.Forms;

public class WorkflowRobusto
{
    [Start]
    public void Function()
    {
        CommandLineInterpreter cli = new CommandLineInterpreter();
        StringBuilder reporte = new StringBuilder();

        // Comando 1: Generar conexiones
        if (cli.Execute("generate"))
            reporte.AppendLine("✓ Generación completada");
        else
            reporte.AppendLine("✗ Error al generar");

        // Comando 2: Comprimir proyecto
        if (cli.Execute("compress"))
            reporte.AppendLine("✓ Compresión completada");
        else
            reporte.AppendLine("✗ Error al comprimir proyecto");

        // Comando 3: Verificar proyecto
        if (cli.Execute("check"))
            reporte.AppendLine("✓ Verificación completada");
        else
            reporte.AppendLine("✗ Error al verificar proyecto");

        // Mostrar reporte final
        MessageBox.Show(reporte.ToString(), "Reporte de Ejecución");
    }
}

Ventaja: Obtienes un reporte completo de qué comandos funcionaron y cuáles no.

4. Workflows comunes con comandos verificados

4.1 Workflow de verificación del sistema

using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;

public class VerificarSistema
{
    [Start]
    public void Function()
    {
        CommandLineInterpreter cli = new CommandLineInterpreter();

        // Generar conexiones y numeración
        cli.Execute("generate");

        // Comprimir proyecto
        cli.Execute("compress");

        // Verificar proyecto
        cli.Execute("check");
    }
}

Uso: Ejecutar al iniciar EPLAN para verificar el estado del sistema.

4.2 Workflow de mantenimiento

using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;
using System.Windows.Forms;

public class MantenimientoProyecto
{
    [Start]
    public void Function()
    {
        try
        {
            CommandLineInterpreter cli = new CommandLineInterpreter();

            // Comprimir proyecto para optimizar almacenamiento
            if (!cli.Execute("compress"))
            {
                MessageBox.Show("No se pudo comprimir el proyecto");
                return;
            }

            MessageBox.Show(
                "Proyecto comprimido correctamente.\n" +
                "El almacenamiento interno ha sido optimizado.",
                "Workflow de Mantenimiento"
            );
        }
        catch (Exception ex)
        {
            MessageBox.Show("Error: " + ex.Message);
        }
    }
}

5. Buenas prácticas para workflows

5.1 Crear CLI una sola vez

Mal:

new CommandLineInterpreter().Execute("generate");
new CommandLineInterpreter().Execute("compress");
new CommandLineInterpreter().Execute("check");

Bien:

CommandLineInterpreter cli = new CommandLineInterpreter();
cli.Execute("generate");
cli.Execute("compress");
cli.Execute("check");

Razón: Crear múltiples instancias consume más recursos innecesariamente.

5.2 Comentar cada paso del workflow

CommandLineInterpreter cli = new CommandLineInterpreter();

// Paso 1: Generar conexiones y numeración
cli.Execute("generate");

// Paso 2: Comprimir proyecto
cli.Execute("compress");

// Paso 3: Verificar proyecto
cli.Execute("check");

Razón: Hace el código más legible y fácil de mantener.

5.3 Usar try-catch general

try
{
    CommandLineInterpreter cli = new CommandLineInterpreter();
    cli.Execute("comando1");
    cli.Execute("comando2");
    cli.Execute("comando3");
}
catch (Exception ex)
{
    MessageBox.Show("Error en workflow: " + ex.Message);
}

Razón: Captura cualquier error inesperado en cualquier comando.

5.4 Informar al usuario

using System.Windows.Forms;

CommandLineInterpreter cli = new CommandLineInterpreter();

MessageBox.Show("Iniciando workflow de verificación...");

cli.Execute("generate");
cli.Execute("compress");
cli.Execute("check");

MessageBox.Show("Workflow completado");

Razón: El usuario sabe qué está pasando y cuándo terminó.

6. Diferencias entre un comando y múltiples comandos

Aspecto	Un comando	Múltiples comandos
Creación de CLI	Opcional guardar en variable	Obligatorio guardar en variable
Manejo de errores	Simple: verificar un retorno	Complejo: verificar múltiples retornos
Complejidad	Baja	Media
Uso típico	Acción única	Workflows, automatizaciones
Tiempo de ejecución	Rápido	Depende del número de comandos

7. Proyecto del capítulo: Workflow completo de verificación

7.1 Objetivo

Crear un workflow que:

Genera conexiones y numeración
Abre la ventana de reportes
Verifica el proyecto en busca de errores
Informa al usuario del resultado de cada paso

7.2 Implementación completa

using System;
using System.Text;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;
using System.Windows.Forms;

public class WorkflowVerificacionCompleto
{
    [Start]
    public void Function()
    {
        try
        {
            // Crear intérprete de comandos
            CommandLineInterpreter cli = new CommandLineInterpreter();

            // Preparar reporte de ejecución
            StringBuilder reporte = new StringBuilder();
            reporte.AppendLine("WORKFLOW DE VERIFICACIÓN");
            reporte.AppendLine("======================");
            reporte.AppendLine();

            // Paso 1: Generar conexiones y numeración
            reporte.Append("1. Generando conexiones... ");
            if (cli.Execute("generate"))
            {
                reporte.AppendLine("OK");
            }
            else
            {
                reporte.AppendLine("ERROR");
            }

            // Paso 2: Comprimir proyecto
            reporte.Append("2. Comprimiendo proyecto... ");
            if (cli.Execute("compress"))
            {
                reporte.AppendLine("OK");
            }
            else
            {
                reporte.AppendLine("ERROR");
            }

            // Paso 3: Verificar proyecto
            reporte.Append("3. Verificando proyecto... ");
            if (cli.Execute("check"))
            {
                reporte.AppendLine("OK");
            }
            else
            {
                reporte.AppendLine("ERROR");
            }

            // Mostrar reporte final
            reporte.AppendLine();
            reporte.AppendLine("Workflow completado.");

            MessageBox.Show(
                reporte.ToString(),
                "Reporte de Verificación",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information
            );
        }
        catch (Exception ex)
        {
            MessageBox.Show(
                "Error al ejecutar workflow:\n" + ex.Message,
                "Error",
                MessageBoxButtons.OK,
                MessageBoxIcon.Error
            );
        }
    }
}

7.3 Salida esperada

Al ejecutar este script, verás un mensaje como:

WORKFLOW DE VERIFICACIÓN
======================

1. Generando conexiones... OK
2. Abriendo ventana de reportes... OK
3. Verificando proyecto... OK

Workflow completado.

Hasta ahora solo puedes ejecutar comandos sin parámetros. Para comandos que necesitan parámetros (como exportar a una ruta específica), necesitas ActionCallingContext, que veremos en el Capítulo 18.

8.2 Sin condicionales entre comandos

Por ahora, todos los comandos se ejecutan siempre. Más adelante aprenderás a:

Ejecutar comando 2 solo si comando 1 tuvo éxito
Saltar comandos según condiciones
Crear workflows más complejos

Resumen

En este capítulo aprendiste:

Puedes ejecutar múltiples comandos con el mismo CommandLineInterpreter
Los comandos se ejecutan en secuencia, uno después del otro
Crear el CLI una sola vez y reutilizarlo es más eficiente
Puedes validar cada comando individualmente o crear reportes completos
Los workflows automatizan tareas repetitivas combinando múltiples comandos
Siempre usa try-catch y comenta cada paso del workflow
StringBuilder es útil para crear reportes de múltiples pasos

Preguntas frecuentes

P: ¿Cuántos comandos puedo ejecutar en un mismo script?

R: No hay un límite definido, pero ten en cuenta el tiempo de ejecución. Workflows de 10-20 comandos son comunes.

P: ¿Los comandos se ejecutan en paralelo o en secuencia?

R: En secuencia. Cada comando espera a que el anterior termine.

P: ¿Qué pasa si el segundo comando depende del resultado del primero?

R: Debes verificar el valor de retorno del primer comando antes de ejecutar el segundo. Esto lo puedes hacer con if (!cli.Execute(...)) return;

P: ¿Puedo ejecutar el mismo comando varias veces?

R: Sí, puedes ejecutar el mismo comando múltiples veces si es necesario.

P: ¿Cómo puedo pausar entre comandos?

R: Usa System.Threading.Thread.Sleep(milliseconds) para pausar entre comandos, aunque generalmente no es necesario.

Última actualización: Enero 2025 Tiempo de lectura estimado: 25-30 minutos Código de ejemplo: code/cap-17/Script de referencia: EPLAN-Scripting-4.0/02_RunActions/02_MultipleActions.cs