Capítulo 12: Arquitectura de EPLAN API

Parte II: Introducción a EPLAN API - Sección 3: Primeros pasos con EPLAN - Nivel: Intermedio

🎯 Objetivos de aprendizaje

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

Entender la arquitectura general de EPLAN API
Distinguir namespaces gratuitos de los de pago
Navegar la documentación oficial eficientemente
Identificar qué puedes hacer gratuitamente sin licencias adicionales
Explorar la API usando scripts 100% gratuitos
Comprender las limitaciones sin DataModel y sus alternativas
Usar PathMap, Settings y CommandLineInterpreter efectivamente
Prepararte para escribir scripts gratuitos en los próximos capítulos

📋 Requisitos previos

Antes de comenzar este capítulo debes:

✅ Haber completado la Parte I (Capítulos 1-11)
✅ Tener EPLAN Electric P8 instalado
✅ Conocer POO básica (clases, objetos, métodos)
✅ Saber manejar excepciones (try-catch)
✅ Tener un proyecto EPLAN de prueba disponible

🏆 Proyecto del capítulo

Explorador de EPLAN API (100% Gratuito)

Al final de este capítulo habrás construido scripts para:

Explorar la estructura de la API
Listar todos los namespaces disponibles e identificar cuáles son gratuitos
Inspeccionar configuración y archivos del proyecto
Generar un “mapa” de qué está disponible gratuitamente
Entender las limitaciones sin DataModel

Tiempo estimado: 60-70 minutos

📚 Contenido

1. Introducción: ¿Qué es EPLAN API?

1.1 Definición

EPLAN API (Application Programming Interface) es el conjunto de clases, métodos y propiedades que EPLAN Electric P8 expone para permitir la automatización y extensión de sus funcionalidades.

Analogía: Si EPLAN fuera un coche:

GUI (interfaz gráfica) = Volante, pedales, botones (lo que ves)
API = Motor, transmisión, sistemas internos (lo que puedes programar)

Con la API puedes:

✅ Automatizar tareas repetitivas
✅ Procesar proyectos en lote
✅ Integrar EPLAN con otros sistemas
✅ Crear herramientas personalizadas

1.2 Dos formas de usar EPLAN API

EPLAN API se puede usar de dos formas principales:

┌─────────────────────────────────────────────────────┐
│              EPLAN API                              │
├─────────────────────────────────────────────────────┤
│                                                     │
│  1. Scripts (C#)                  2. Add-ins (DLL) │
│     - Archivos .cs                   - Proyectos   │
│     - Ejecutar desde EPLAN           - Instalables │
│     - Desarrollo rápido              - Más potente │
│     - Sin compilación                - Interfaz    │
│     - Ideal para empezar             - Profesional │
│                                                     │
└─────────────────────────────────────────────────────┘

Este libro se enfoca en Scripts porque:

No requieren Visual Studio
No necesitan compilación
Más rápidos de desarrollar
Fáciles de distribuir
Suficientes para la mayoría de automatizaciones

2. Arquitectura de EPLAN API: Lo Gratuito vs Lo de Pago

2.1 Visión general

EPLAN API está organizada en namespaces (espacios de nombres). CRÍTICO: No todos los namespaces son gratuitos.

Eplan.EplApi
├── ApplicationFramework     ✅ GRATUITO
├── Base                    ✅ GRATUITO
├── Scripting               ✅ GRATUITO
├── Gui                     ✅ GRATUITO
├── MasterData              ✅ GRATUITO (limitado)
├── DataModel               ❌ DE PAGO (requiere licencia)
└── HEServices              ❌ DE PAGO (requiere licencia)

⚠️ IMPORTANTE: Este libro se enfoca en los namespaces 100% GRATUITOS.

2.2 ¿Qué significa “DE PAGO”?

Los namespaces Eplan.EplApi.DataModel y Eplan.EplApi.HEServices:

Requieren licencia adicional de EPLAN
No funcionan sin la licencia (lanzan excepciones o fallan silenciosamente)
Son para acceso directo al modelo de datos (crear/modificar objetos eléctricos)
Son más costosos

La buena noticia: Puedes automatizar el 80% de tareas sin estas licencias usando alternativas gratuitas.

3. Los namespaces GRATUITOS fundamentales

3.1 Eplan.EplApi.ApplicationFramework ✅

Propósito: Gestión de la aplicación EPLAN y ejecución de comandos CLI.

Clases principales:

CommandLineInterpreter: Ejecutar comandos de EPLAN
ActionCallingContext: Parámetros para comandos
Application: Información de la aplicación

Cuándo usar:

Ejecutar acciones de EPLAN (exportar, generar, abrir proyectos)
Automatizar workflows
Orquestar operaciones complejas

Ejemplo:

using Eplan.EplApi.ApplicationFramework;

CommandLineInterpreter cli = new CommandLineInterpreter();
cli.Execute("generate");  // Generar conexiones
cli.Execute("save");      // Guardar proyecto

💡 Ventaja: La mayoría de funciones de EPLAN están disponibles via CLI gratuitamente.

3.2 Eplan.EplApi.Base ✅

Propósito: Clases base, utilidades, y configuración.

Clases principales:

PathMap: Variables de sistema de EPLAN (40+ variables)
Settings: Configuraciones de EPLAN
BaseException: Sistema de mensajes
Progress: Barras de progreso

Cuándo usar:

Obtener información del proyecto actual
Leer/modificar configuraciones
Mostrar mensajes al usuario
Crear barras de progreso

Ejemplo:

using Eplan.EplApi.Base;

// PathMap: Obtener información del proyecto
string nombreProyecto = PathMap.SubstitutePath("$(PROJECTNAME)");
string rutaProyecto = PathMap.SubstitutePath("$(PROJECTPATH)");
string versionEplan = PathMap.SubstitutePath("$(EPLAN_VERSION)");

// Settings: Leer configuración
Settings settings = new Settings();
string idioma = settings.GetStringSetting("USER.LANGUAGE.GUI", 0);

// BaseException: Mostrar mensajes
new BaseException("Proceso completado", MessageLevel.Message).FixMessage();

// Progress: Barra de progreso
Progress progress = new Progress("SimpleProgress");
progress.BeginPart(100, "Procesando...");
progress.Step(50, "Mitad completado");
progress.EndPart();

💡 PathMap es tu mejor amigo: Tiene más de 40 variables disponibles gratuitamente.

3.3 Eplan.EplApi.Scripting ✅

Propósito: Herramientas específicas para scripts.

Atributos principales:

[Start]: Marca el punto de entrada del script
[DeclareAction]: Declara acciones personalizadas
[DeclareMenu]: Agregar elementos al menú

Ejemplo:

using Eplan.EplApi.Scripting;

public class MiScript
{
    [Start]
    public void Ejecutar()
    {
        // Código del script
    }
}

3.4 System.* (Framework .NET) ✅

Namespaces estándar de .NET disponibles gratuitamente:

System.IO: Operaciones de archivos
System.Windows.Forms: Crear interfaces gráficas
System.Xml.Linq: Parsear XML
System.Linq: Consultas LINQ
Newtonsoft.Json: Procesar JSON

Ejemplo:

using System.IO;
using System.Windows.Forms;

// Leer archivos del proyecto
DirectoryInfo dir = new DirectoryInfo(rutaProyecto);
FileInfo[] archivos = dir.GetFiles("*.xml");

// Mostrar diálogo
MessageBox.Show("Proceso completado", "Información");

4. Los namespaces DE PAGO (que NO usaremos)

4.1 Eplan.EplApi.DataModel ❌

Propósito: Acceso directo al modelo de datos (crear/modificar objetos eléctricos).

Clases principales (que NO podemos usar sin licencia):

Project: Representa un proyecto
Page: Página del proyecto
Function: Componente eléctrico
Device: Dispositivo
Connection: Conexión eléctrica

Por qué es de pago:

Permite crear/modificar/eliminar objetos directamente
Acceso completo a propiedades
Navegación de jerarquías
Es el “motor” interno de EPLAN

Alternativas gratuitas:

CommandLineInterpreter: Muchas operaciones disponibles via CLI
PathMap + Settings: Información del proyecto
System.IO: Leer archivos .elk (son ZIPs con XMLs)
Exportar y parsear: Exporta a XML/CSV con CLI, luego parsea

4.2 Eplan.EplApi.HEServices ❌

Propósito: Servicios de ingeniería de alto nivel.

Clases principales (que NO podemos usar sin licencia):

GenerateService: Generar conexiones
DrawingService: Operaciones de dibujo
CableService: Gestión de cables
DMObjectsFinder: Búsquedas complejas

Alternativa gratuita:

Usa CommandLineInterpreter con comandos como generate, synchronize, compile

5. CommandLineInterpreter: Tu herramienta gratuita más poderosa

El CommandLineInterpreter es tu mejor aliado para automatización gratuita.

5.1 Comandos CLI comunes (100% gratuitos)

Gestión de proyectos:

CommandLineInterpreter cli = new CommandLineInterpreter();

// Guardar proyecto
cli.Execute("save");

// Abrir proyecto
ActionCallingContext ctx = new ActionCallingContext();
ctx.AddParameter("PROJECTNAME", @"C:\Proyectos\Demo.elk");
ctx.AddParameter("TYPE", "PROJECT");
cli.Execute("XPrjActionProjectOpen", ctx);

// Cerrar proyecto
cli.Execute("XPrjActionProjectClose");

Generación y sincronización:

// Generar conexiones
cli.Execute("generate");

// Sincronizar
cli.Execute("synchronize");

// Compilar numeración
cli.Execute("compile");

Exportación:

// Exportar PDF
ActionCallingContext ctxPDF = new ActionCallingContext();
ctxPDF.AddParameter("TYPE", "PDF");
ctxPDF.AddParameter("EXPORTFILE", @"C:\Salida\Planos.pdf");
ctxPDF.AddParameter("SHOWCONFIGDIALOG", "0");
cli.Execute("export", ctxPDF);

// Exportar DWF
ActionCallingContext ctxDWF = new ActionCallingContext();
ctxDWF.AddParameter("TYPE", "DWF");
ctxDWF.AddParameter("EXPORTFILE", @"C:\Salida\Planos.dwf");
cli.Execute("export", ctxDWF);

Reportes:

// Lista de materiales
ActionCallingContext ctxBOM = new ActionCallingContext();
ctxBOM.AddParameter("TYPE", "PARTSLIST");
ctxBOM.AddParameter("EXPORTFILE", @"C:\Salida\BOM.csv");
cli.Execute("reports", ctxBOM);

// Lista de terminales
ActionCallingContext ctxTerminal = new ActionCallingContext();
ctxTerminal.AddParameter("TYPE", "TERMINAL");
ctxTerminal.AddParameter("EXPORTFILE", @"C:\Salida\Terminales.csv");
cli.Execute("reports", ctxTerminal);

5.2 ¿Cómo descubrir más comandos CLI?

Acciones de EPLAN: La mayoría tienen nombre CLI
Documentación: Busca “Action” en EplanAPI.chm
Macro recorder: Graba macros y ve los comandos generados
Trial and error: Prueba variantes de nombres

6. PathMap: 40+ variables gratuitas

PathMap.SubstitutePath() te da acceso a información valiosa del sistema.

6.1 Variables más útiles

Proyecto actual:

string nombre = PathMap.SubstitutePath("$(PROJECTNAME)");
string ruta = PathMap.SubstitutePath("$(PROJECTPATH)");
string rutaCompleta = PathMap.SubstitutePath("$(P)");
string descripcion = PathMap.SubstitutePath("$(PROJECTDESCRIPTION)");

Información de EPLAN:

string eplanPath = PathMap.SubstitutePath("$(EPLAN)");
string version = PathMap.SubstitutePath("$(EPLAN_VERSION)");
string variante = PathMap.SubstitutePath("$(EPLAN_VARIANT)");
string bin = PathMap.SubstitutePath("$(BIN)");

Master Data:

string proyectos = PathMap.SubstitutePath("$(MD_PROJECTS)");
string macros = PathMap.SubstitutePath("$(MD_MACROS)");
string simbolos = PathMap.SubstitutePath("$(MD_SYMBOLS)");
string articulos = PathMap.SubstitutePath("$(MD_PARTS)");
string scripts = PathMap.SubstitutePath("$(MD_SCRIPTS)");

Sistema:

string usuario = PathMap.SubstitutePath("$(USERNAME)");
string computadora = PathMap.SubstitutePath("$(COMPUTERNAME)");
string temp = PathMap.SubstitutePath("$(TMP)");
string fecha = PathMap.SubstitutePath("$(LOCALDATE)");
string hora = PathMap.SubstitutePath("$(LOCALTIME)");

6.2 Verificar si variable existe

string valor = PathMap.SubstitutePath("$(PROJECTNAME)");

// Si la variable no existe o no tiene valor, retorna la variable sin sustituir
if (valor.StartsWith("$("))
{
    Console.WriteLine("Variable no disponible o sin valor");
}
else
{
    Console.WriteLine("Nombre del proyecto: " + valor);
}

7. Alternativas gratuitas a DataModel

7.1 Leer información de proyecto

Con DataModel (DE PAGO):

// ❌ Requiere licencia
Project project = new Project();
project.Open(@"C:\Demo.elk", ProjectOpenMode.Shared);
string nombre = project.ProjectName;
Page[] paginas = project.Pages;

Alternativa GRATUITA con PathMap:

// ✅ Gratuito
string nombre = PathMap.SubstitutePath("$(PROJECTNAME)");
string ruta = PathMap.SubstitutePath("$(PROJECTPATH)");

Alternativa GRATUITA con System.IO:

// ✅ Los archivos .elk son ZIP files
string archivoElk = ruta + ".elk";
FileInfo info = new FileInfo(archivoElk);
long tamanioMB = info.Length / 1048576;

// Extraer contenido
using (ZipArchive zip = ZipFile.OpenRead(archivoElk))
{
    foreach (ZipArchiveEntry entry in zip.Entries)
    {
        Console.WriteLine(entry.FullName);
    }
}

7.2 Obtener datos del proyecto

Con DataModel (DE PAGO):

// ❌ Requiere licencia
foreach (Page pagina in project.Pages)
{
    foreach (Function funcion in pagina.Functions)
    {
        string nombre = funcion.Name;
    }
}

Alternativa GRATUITA: Exportar y parsear:

// ✅ Paso 1: Exportar a XML con CLI
ActionCallingContext ctx = new ActionCallingContext();
ctx.AddParameter("TYPE", "PARTSLIST");
ctx.AddParameter("EXPORTFILE", @"C:\temp\datos.xml");
cli.Execute("reports", ctx);

// ✅ Paso 2: Parsear XML con System.Xml.Linq
XDocument doc = XDocument.Load(@"C:\temp\datos.xml");
var articulos = doc.Descendants("Article")
    .Select(a => new {
        Numero = a.Attribute("PartNr")?.Value,
        Fabricante = a.Attribute("Manufacturer")?.Value
    });

foreach (var art in articulos)
{
    Console.WriteLine($"{art.Fabricante} - {art.Numero}");
}

7.3 Búsquedas complejas

Con DataModel (DE PAGO):

// ❌ Requiere licencia HEServices
DMObjectsFinder finder = new DMObjectsFinder(project);
Function[] motores = finder.GetFunctions(new FunctionsFilter()
{
    Category = "MotorStarters"
});

Alternativa GRATUITA:

// ✅ Exportar lista de funciones y filtrar
cli.Execute("reports", ctx); // Exportar a CSV
string[] lineas = File.ReadAllLines(@"C:\temp\funciones.csv");

var motores = lineas
    .Where(l => l.Contains("Motor") || l.Contains("3~"))
    .ToList();

8. Navegando la documentación oficial

8.1 ¿Dónde está?

Ubicación física:

C:\Program Files\EPLAN\Electric P8\<versión>\Bin\EplanAPI.chm

Acceso desde EPLAN:

Menú: Ayuda → API Reference
Se abre el archivo CHM (Windows Help)

8.2 ⚠️ Cuidado con la documentación

IMPORTANTE: La documentación NO marca qué requiere licencia.

Cómo identificar si requiere licencia:

¿El namespace es Eplan.EplApi.DataModel? → DE PAGO
¿El namespace es Eplan.EplApi.HEServices? → DE PAGO
¿Es ApplicationFramework, Base, Scripting? → GRATUITO

8.3 Estrategia de búsqueda

¿Necesitas...?                    →  Busca en...
────────────────────────────────     ─────────────────────────
Ejecutar comando                  →  CommandLineInterpreter
Info del proyecto                 →  PathMap
Configuración                     →  Settings
Mostrar mensajes                  →  BaseException
Exportar/generar/traducir         →  CLI commands
Leer archivos                     →  System.IO
Crear GUI                         →  System.Windows.Forms

💻 Manos a la obra: Explorando la API (100% Gratuito)

Proyecto 1: Inspector de Namespaces

Este script lista todos los namespaces de EPLAN API y te ayuda a identificar cuáles son gratuitos.

//
// Proyecto: Inspector de Namespaces EPLAN API (100% GRATUITO)
// Capítulo: 12
// Descripción: Explora y lista todos los namespaces disponibles
//

using System;
using System.Reflection;
using System.Collections.Generic;
using Eplan.EplApi.Base;
using Eplan.EplApi.ApplicationFramework;

public class InspectorNamespaces
{
    [Start]
    public void Ejecutar()
    {
        try
        {
            // Obtener todos los assemblies cargados
            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();

            List<string> namespacesEplan = new List<string>();

            foreach (Assembly assembly in assemblies)
            {
                if (assembly.FullName.Contains("Eplan.EplApi"))
                {
                    try
                    {
                        Type[] tipos = assembly.GetTypes();

                        foreach (Type tipo in tipos)
                        {
                            if (tipo.Namespace != null &&
                                tipo.Namespace.StartsWith("Eplan.EplApi") &&
                                !namespacesEplan.Contains(tipo.Namespace))
                            {
                                namespacesEplan.Add(tipo.Namespace);
                            }
                        }
                    }
                    catch
                    {
                        continue;
                    }
                }
            }

            namespacesEplan.Sort();

            // Generar reporte
            string reporte = "NAMESPACES DE EPLAN API\n";
            reporte += "========================================\n\n";
            reporte += string.Format("Total: {0} namespaces\n\n", namespacesEplan.Count);

            // Agrupar por categoría y marcar gratuitos/pagos
            Dictionary<string, List<string>> categorias = new Dictionary<string, List<string>>();

            foreach (string ns in namespacesEplan)
            {
                string[] partes = ns.Split('.');
                string categoria = partes.Length > 2 ? partes[2] : "Otros";

                if (!categorias.ContainsKey(categoria))
                {
                    categorias[categoria] = new List<string>();
                }

                categorias[categoria].Add(ns);
            }

            // Mostrar por categorías
            foreach (var cat in categorias)
            {
                bool esGratuito = EsNamespaceGratuito(cat.Key);
                string marcador = esGratuito ? "✅ GRATUITO" : "❌ DE PAGO";

                reporte += string.Format("\n{0} ({1}) {2}:\n", cat.Key, cat.Value.Count, marcador);
                reporte += "----------------------------------------\n";

                foreach (string ns in cat.Value)
                {
                    reporte += "  • " + ns + "\n";
                }
            }

            reporte += "\n========================================\n";
            reporte += "⚠️ IMPORTANTE:\n";
            reporte += "• DataModel y HEServices requieren licencia\n";
            reporte += "• Este libro usa SOLO namespaces gratuitos\n";
            reporte += "========================================\n";

            new BaseException(reporte, MessageLevel.Message).FixMessage();
        }
        catch (Exception ex)
        {
            new BaseException("Error: " + ex.Message, MessageLevel.Error).FixMessage();
        }
    }

    private bool EsNamespaceGratuito(string categoria)
    {
        string[] gratuitos = {
            "ApplicationFramework", "Base", "Scripting",
            "Gui", "MasterData", "IdentityClient"
        };

        foreach (string g in gratuitos)
        {
            if (categoria.Equals(g, StringComparison.OrdinalIgnoreCase))
                return true;
        }

        return false;
    }
}

Proyecto 2: Explorador de Configuración y Archivos

Este script explora el proyecto actual usando SOLO herramientas gratuitas.

//
// Proyecto: Explorador de Configuración y Archivos (100% GRATUITO)
// Capítulo: 12
// Descripción: Explora proyecto sin DataModel
//

using System;
using System.IO;
using System.Collections.Generic;
using Eplan.EplApi.Base;
using Eplan.EplApi.ApplicationFramework;
using Eplan.EplApi.Scripting;

public class ExploradorProyecto
{
    [Start]
    public void Ejecutar()
    {
        try
        {
            // Obtener información básica con PathMap
            string nombreProyecto = PathMap.SubstitutePath("$(PROJECTNAME)");
            string rutaProyecto = PathMap.SubstitutePath("$(PROJECTPATH)");

            if (string.IsNullOrEmpty(nombreProyecto) || nombreProyecto.StartsWith("$("))
            {
                new BaseException(
                    "No hay proyecto abierto.\n\n" +
                    "Por favor, abre un proyecto en EPLAN.",
                    MessageLevel.Warning
                ).FixMessage();
                return;
            }

            Progress progress = new Progress("SimpleProgress");
            progress.BeginPart(100, "Explorando...");

            try
            {
                string reporte = "═══════════════════════════════════════════════\n";
                reporte += "   EXPLORADOR DE CONFIGURACIÓN Y ARCHIVOS\n";
                reporte += "═══════════════════════════════════════════════\n\n";

                // Información del proyecto (PathMap)
                progress.Step(25, "Analizando proyecto...");
                reporte += "📁 INFORMACIÓN DEL PROYECTO\n";
                reporte += "───────────────────────────────────────────────\n";
                reporte += string.Format("Nombre: {0}\n", nombreProyecto);
                reporte += string.Format("Ruta: {0}\n", rutaProyecto);
                reporte += string.Format("Versión EPLAN: {0}\n\n",
                    PathMap.SubstitutePath("$(EPLAN_VERSION)"));

                // Archivos (System.IO)
                progress.Step(25, "Explorando archivos...");
                reporte += "📦 ESTRUCTURA DE ARCHIVOS\n";
                reporte += "───────────────────────────────────────────────\n";

                string archivoElk = rutaProyecto.TrimEnd('\\') + ".elk";
                if (File.Exists(archivoElk))
                {
                    FileInfo info = new FileInfo(archivoElk);
                    reporte += string.Format("Tamaño .elk: {0:N2} MB\n",
                        info.Length / 1048576.0);
                }

                if (Directory.Exists(rutaProyecto))
                {
                    DirectoryInfo dir = new DirectoryInfo(rutaProyecto);
                    FileInfo[] archivos = dir.GetFiles("*.*", SearchOption.AllDirectories);
                    reporte += string.Format("Archivos totales: {0}\n\n", archivos.Length);
                }

                // Variables EPLAN (PathMap)
                progress.Step(25, "Listando variables...");
                reporte += "🔧 VARIABLES DE EPLAN\n";
                reporte += "───────────────────────────────────────────────\n";

                string[] variables = {
                    "$(EPLAN)", "$(MD_PROJECTS)", "$(MD_MACROS)",
                    "$(USERNAME)", "$(LOCALDATE)"
                };

                foreach (string var in variables)
                {
                    string valor = PathMap.SubstitutePath(var);
                    reporte += string.Format("{0} = {1}\n", var, valor);
                }
                reporte += "\n";

                // Configuración (Settings)
                progress.Step(25, "Leyendo configuración...");
                reporte += "⚙️ CONFIGURACIÓN\n";
                reporte += "───────────────────────────────────────────────\n";

                Settings settings = new Settings();
                string idioma = settings.GetStringSetting("USER.LANGUAGE.GUI", 0);
                reporte += string.Format("Idioma: {0}\n\n", idioma);

                reporte += "═══════════════════════════════════════════════\n";
                reporte += "ℹ️ NOTA: Este explorador usa SOLO herramientas\n";
                reporte += "   gratuitas (PathMap, Settings, System.IO).\n";
                reporte += "   Sin DataModel no podemos explorar objetos\n";
                reporte += "   eléctricos directamente.\n";
                reporte += "═══════════════════════════════════════════════\n";

                new BaseException(reporte, MessageLevel.Message).FixMessage();
            }
            finally
            {
                progress.EndPart();
            }
        }
        catch (Exception ex)
        {
            new BaseException("Error: " + ex.Message, MessageLevel.Error).FixMessage();
        }
    }
}

⚠️ Nota: Ya no incluimos el script “ComparadorCLIvsDataModel” porque no podemos usar DataModel sin licencia.

🔍 Deep Dive: Lo que SÍ puedes hacer gratuitamente

1. Automatización con CLI

Exportaciones:

PDF, DWF, DXF completos del proyecto
Reportes: BOM, terminales, cables, conexiones
Diferentes configuraciones y esquemas

Procesamiento:

Generar conexiones (generate)
Sincronizar (synchronize)
Compilar numeración (compile)
Verificar proyecto (check)

Gestión de proyectos:

Abrir/cerrar proyectos
Guardar
Crear backups
Traducir

2. Acceso a información con PathMap

40+ variables disponibles:

Información del proyecto actual
Rutas del sistema
Configuración de EPLAN
Usuario y sistema operativo
Fechas y horas

3. Procesamiento de datos externos

JSON con Newtonsoft.Json:

Serializar configuraciones
Deserializar datos
Intercambiar con otros sistemas

XML con System.Xml.Linq:

Parsear exportaciones de EPLAN
Extraer datos específicos
Transformar información

CSV con System.IO:

Leer/escribir archivos tabulares
Compatible con Excel
Importar/exportar datos

4. Interfaces gráficas con Windows.Forms

Diálogos personalizados
Formularios de entrada
Listas y tablas
Barras de progreso visuales
Menús contextuales

5. Análisis de archivos del proyecto

Los archivos .elk son ZIP:

Extraer contenido
Analizar XMLs internos
Examinar estructura
Recuperar datos

📝 Resumen

En este capítulo aprendiste:

✅ Arquitectura de EPLAN API: Estructura de namespaces
✅ Namespaces gratuitos: ApplicationFramework, Base, Scripting, Gui
✅ Namespaces de pago: DataModel y HEServices (que NO usaremos)
✅ CommandLineInterpreter: Tu herramienta gratuita más poderosa
✅ PathMap: 40+ variables disponibles gratuitamente
✅ Alternativas sin DataModel: Cómo automatizar sin licencias
✅ Exploradores construidos: Scripts 100% gratuitos

Conceptos clave:

No todos los namespaces de EPLAN API son gratuitos
DataModel y HEServices requieren licencia adicional
Puedes automatizar el 80% de tareas sin licencias usando CLI
PathMap, Settings y System.* son tus aliados gratuitos
La estrategia: Exportar con CLI → Procesar con .NET

Lo más importante: Este libro te enseña a automatizar EPLAN completamente gratis, sin necesitar licencias adicionales.

🔗 Conexiones

⬅️ Capítulo anterior

Capítulo 11: Manejo de errores

➡️ Próximo capítulo

Capítulo 13: Tu primer script EPLAN (100% gratuito)

En el próximo capítulo escribirás scripts funcionales reales usando SOLO herramientas gratuitas.

📚 Recursos adicionales

📖 Documentación oficial: C:\Program Files\EPLAN\Electric P8\<versión>\Bin\EplanAPI.chm
📖 EPLAN Help Portal: https://www.eplan.help/
💻 Código completo: code/cap-12/
⚠️ Nota: Al leer la documentación, recuerda que DataModel/HEServices son de pago

❓ Preguntas frecuentes

P: ¿Realmente puedo automatizar sin DataModel?

R: Sí. Este libro completo está basado en automatización 100% gratuita. Usamos CLI, PathMap, Settings, System.IO y procesamiento externo. El 80% de automatizaciones no necesitan DataModel.

P: ¿Qué pasa si intento usar DataModel sin licencia?

R: Depende de la versión de EPLAN. Puede:

Lanzar excepciones
Fallar silenciosamente
Retornar datos vacíos
Mostrar mensajes de licencia

Por eso este libro NO usa DataModel.

P: ¿Vale la pena comprar la licencia DataModel?

R: Depende:

SÍ si necesitas: Crear objetos programáticamente, modificaciones masivas complejas, búsquedas avanzadas en tiempo real
NO si solo necesitas: Exportar, generar reportes, automatizar workflows, procesar datos externamente

P: ¿Puedo combinar scripts gratuitos con DataModel después?

R: Sí. Si más adelante compras la licencia, puedes mejorar tus scripts. Pero NO es necesario para el 80% de casos.

P: ¿Los comandos CLI son estables entre versiones?

R: Sí, mucho más estables que DataModel. Los comandos CLI cambian poco entre versiones de EPLAN.

P: ¿Hay una lista completa de comandos CLI?

R: No oficial. Pero puedes:

Usar el macro recorder
Revisar la documentación de “Actions”
Experimentar con nombres
Ver los ejemplos de este libro

📋 Checklist de completitud

Antes de pasar al siguiente capítulo, asegúrate de:

Entender qué namespaces son gratuitos y cuáles no
Saber que DataModel/HEServices son DE PAGO
Conocer al menos 10 variables de PathMap
Haber ejecutado los 2 scripts exploradores
Entender cómo funciona CommandLineInterpreter
Comprender las alternativas sin DataModel
Aceptar que automatizarás TODO el libro sin licencias adicionales

¡Felicitaciones! Ya entiendes la arquitectura de EPLAN API (versión GRATUITA). 🎉

Ahora estás listo para escribir scripts reales 100% gratuitos que automatizan tareas en EPLAN.

¿Listo para tu primer script funcional gratuito? ¡Vamos al Capítulo 13! 🚀

Última actualización: Enero 2025 Tiempo de lectura estimado: 60-70 minutos Código de ejemplo: code/cap-12/ (100% GRATUITO)

📂 Código del Capítulo

Todos los scripts de este capítulo están disponibles en GitHub:

📥 Ver código en GitHub →

Los scripts son 100% funcionales y usan únicamente APIs gratuitas de EPLAN.

🔓 Desbloquea el Contenido Completo

¿Te gustó este capítulo? Hay 25 capítulos más esperándote con:

✅ Scripts profesionales completos
✅ Casos de estudio reales
✅ Suite de automatización integrada
✅ Ahorra 80-95% de tiempo en tareas repetitivas

💎 Ver Libro Completo ($79)