Capítulo 22: Métodos con valor de retorno en C#

Parte IV: Flujo de control y decisiones - Sección 9: Métodos y organización - Nivel: Principiante

Objetivos de aprendizaje

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

• Crear métodos auxiliares que retornan valores (bool, string, int)
• Refactorizar código complejo moviendo lógica a métodos separados
• Usar el valor de retorno para tomar decisiones en el flujo del script
• Escribir código más limpio y mantenible

Requisitos previos

• Conocimiento básico de métodos en C# (Parte I)
• Atributo Start
• MessageBox

Introducción: Limpiando el método Start

A medida que tus scripts crecen, el método [Start] puede volverse enorme y difícil de leer.

Código desordenado:

[Start]
public void Function()
{
    // 50 líneas de validación
    // 30 líneas de cálculo
    // 20 líneas de exportación
}

Código limpio:

[Start]
public void Function()
{
    if (!ValidarProyecto()) return;
    
    int total = CalcularTotal();
    Exportar(total);
}

Para lograr esto, necesitas métodos que retornen valores.

1. Métodos con retorno en EPLAN Scripts

La sintaxis es C# estándar. Lo importante es cómo aplicarlo para interactuar con la API de EPLAN.

1.1 Sintaxis básica

private TipoDeDato NombreDelMetodo(Parametros)
{
    // Lógica
    return valor;
}

1.2 Ejemplo: Validar proyecto

Basado en EPLAN-Scripting-4.0/04_CodeFlow/06_MethodReturnValue.cs:

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

public class MetodosConRetorno
{
    [Start]
    public void Function()
    {
        // Llamar al método y usar su resultado
        if (CheckProjectName())
        {
            MessageBox.Show("El proyecto es válido. Continuando...");
            // Lógica principal aquí
        }
        else
        {
            MessageBox.Show("Operación cancelada.");
        }
    }

    // Método auxiliar que retorna un booleano
    private bool CheckProjectName()
    {
        string projectName = PathMap.SubstitutePath("$(PROJECTNAME)");

        if (string.IsNullOrEmpty(projectName) || projectName.StartsWith("$("))
        {
            MessageBox.Show("Error: No hay proyecto abierto.");
            return false;
        }

        if (projectName.Contains("DEMO"))
        {
            MessageBox.Show("Advertencia: Es un proyecto DEMO.");
            // Aun así permitimos continuar, pero avisamos
            return true;
        }

        return true;
    }
}

Análisis:

• CheckProjectName encapsula la lógica de obtener y validar el nombre.
• El método [Start] queda limpio: "Si el proyecto es válido, continuar".

2. Retornar Strings y Números

2.1 Método para obtener rutas

private string GetExportPath(string fileName)
{
    string projectPath = PathMap.SubstitutePath("$(PROJECTPATH)");
    return System.IO.Path.Combine(projectPath, "Export", fileName);
}

Uso:

string fullPath = GetExportPath("listado.txt");

2.2 Método para cálculos

private int CalcularPaginas(int esquematicas, int reportes)
{
    // Lógica de negocio encapsulada
    return esquematicas + reportes;
}

3. Salida temprana (Early Return)

El return no solo devuelve un valor, también termina la ejecución del método inmediatamente. Esto es muy útil para validaciones (Guards).

Sin Early Return (Nested Ifs - "Arrow Code"):

public bool Validar()
{
    if (Condicion1)
    {
        if (Condicion2)
        {
            if (Condicion3)
            {
                return true;
            }
        }
    }
    return false;
}

Con Early Return (Cleaner):

public bool Validar()
{
    if (!Condicion1) return false;
    if (!Condicion2) return false;
    if (!Condicion3) return false;

    return true;
}

4. Proyecto del capítulo: Calculadora de Nombres

Vamos a crear un script que genere nombres de archivo estandarizados usando métodos auxiliares.

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

public class GeneradorDeNombres
{
    [Start]
    public void Function()
    {
        string nombreBase = GetProjectName();
        if (string.IsNullOrEmpty(nombreBase)) return;

        string fecha = GetFormattedDate();
        string nombreFinal = GenerateFileName(nombreBase, fecha, "PDF");

        MessageBox.Show("Archivo generado será: " + nombreFinal);
    }

    // Método 1: Obtener nombre limpio
    private string GetProjectName()
    {
        string pName = PathMap.SubstitutePath("$(PROJECTNAME)");
        if (pName.StartsWith("$(")) return null;
        return pName;
    }

    // Método 2: Obtener fecha formato ISO
    private string GetFormattedDate()
    {
        return DateTime.Now.ToString("yyyyMMdd");
    }

    // Método 3: Combinar partes
    private string GenerateFileName(string project, string date, string extension)
    {
        return string.Format("{0}_{1}_Export.{2}", project, date, extension);
    }
}

Resumen

• Mueve la lógica compleja fuera de [Start].
• Usa métodos private con tipos de retorno (bool, string, etc.).
• Aprovecha el return para salir temprano de validaciones fallidas.
• Nombra tus métodos con verbos que indiquen qué retornan (Get..., Check..., Calculate...).

Conexiones

Capítulo anterior

Capítulo 21: BaseException - Mensajes del sistema

Próximo capítulo

Capítulo 23: Sobrecarga de métodos

En el próximo capítulo aprenderás a crear múltiples versiones de un mismo método para manejar diferentes situaciones (polimorfismo estático).