Capítulo 3: Variables y tipos de datos en C#

7 min de lectura

Parte I - Sección 1: Fundamentos de C# - Nivel: Principiante

Objetivos de aprendizaje

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

Entender qué es una variable y por qué las necesitamos en programación
Declarar y usar los tipos de datos básicos en C# (string, int, double, bool)
Aplicar convenciones de nombres correctas para variables
Realizar conversiones entre diferentes tipos de datos
Calcular valores de circuitos eléctricos usando variables

Requisitos previos

Antes de comenzar este capítulo debes:

Haber completado el Capítulo 2
Tener tu entorno de scripts configurado
Poder ejecutar scripts en EPLAN

Proyecto del capítulo

Calculadora de Circuitos Básicos

Al final de este capítulo habrás construido un script que calcula:

Resistencia total en serie
Voltaje usando Ley de Ohm
Potencia de un circuito
Conversiones de unidades eléctricas

Tiempo estimado: 30-40 minutos

Contenido

1. Introducción: ¿Qué es una variable?

Imagina que estás diseñando un circuito y necesitas anotar varios valores:

Voltaje de entrada: 230V
Corriente: 16A
Factor de potencia: 0.85

En papel, escribirías estos valores en algún lugar. En programación, las variables son contenedores con nombre donde guardamos valores.

Analogía con la ingeniería

Piensa en las variables como puntos de medición etiquetados en un esquema:

[230V] ----[R1]----[R2]---- [GND]
  ↑         ↑       ↑
voltaje    res1    res2

Cada punto tiene un nombre (voltaje, res1, res2) y un valor (230, 100, 220).

En C#, esto sería:

double voltaje = 230.0;
double res1 = 100.0;
double res2 = 220.0;

2. Tipos de datos básicos en C#

C# es un lenguaje fuertemente tipado. Esto significa que cada variable tiene un tipo específico que define:

Qué tipo de información puede almacenar
Cuánta memoria ocupa
Qué operaciones puedes hacer con ella

Los 4 tipos básicos que usarás constantemente son:

2.1 string - Texto

Uso: Para almacenar palabras, frases, nombres, descripciones.

string proyecto = "Armario Principal";
string cliente = "Industrias XYZ";
string ubicacion = "Planta 2 - Sección A";

Características:

Se declara con comillas dobles: "texto"
Puede contener cualquier carácter (letras, números, símbolos)
Inmutable (no puedes modificar caracteres individuales directamente)

Ejemplos prácticos en EPLAN:

string nombreProyecto = "P-2025-001";
string designacion = "Q1";
string fabricante = "Siemens";
string descripcion = "Contactor principal 3P 65A";

2.2 int - Números enteros

Uso: Para cantidades completas sin decimales.

int numeroPages = 45;
int cantidadBornes = 120;
int año = 2025;

Características:

Solo números enteros: -2147483648 a 2147483647
Sin decimales
Operaciones matemáticas: +, -, *, /, %

Ejemplos prácticos en EPLAN:

int numeroPagina = 15;
int cantidadCables = 247;
int numeroCircuito = 3;
int potenciaNominal = 400;  // Watts como número entero

Caso típico: Contar elementos

int totalContactores = 12;
int contactoresUsados = 8;
int contactoresDisponibles = totalContactores - contactoresUsados;  // 4

2.3 double - Números decimales

Uso: Para valores con decimales (mediciones eléctricas, cálculos precisos).

double voltaje = 230.5;
double corriente = 16.3;
double resistencia = 10.75;

Características:

Números con decimales
Precisión de ~15-17 dígitos decimales
Se usa punto (.) como separador decimal (no coma)

Ejemplos prácticos en EPLAN:

double voltajeLinea = 400.0;
double corrienteNominal = 16.5;
double factorPotencia = 0.92;
double seccionCable = 2.5;  // mm²
double longitudCable = 47.8;  // metros

Caso típico: Ley de Ohm

double voltaje = 230.0;     // V
double corriente = 10.5;    // A
double resistencia = voltaje / corriente;  // 21.90476... Ω

Nota importante: Siempre usa .0 aunque sea número entero para que C# lo trate como double:

double valor1 = 100.0;   // Correcto
double valor2 = 100;     // También funciona, pero menos claro

2.4 bool - Valores lógicos (verdadero/falso)

Uso: Para condiciones, estados, banderas.

bool proyectoAbierto = true;
bool tieneErrores = false;
bool esEmergencia = true;

Características:

Solo dos valores posibles: true o false
Fundamental para tomar decisiones (lo veremos en Capítulo 5)
No se escribe entre comillas

Ejemplos prácticos en EPLAN:

bool proyectoModificado = true;
bool exportacionExitosa = false;
bool requiereAprobacion = true;
bool esTrifasico = true;
bool tieneProteccionDiferencial = false;

Caso típico: Estados del proyecto

bool proyectoGuardado = false;
bool cambiosPendientes = true;
bool backupRealizado = true;

3. Declaración y asignación de variables

3.1 Declaración básica

La sintaxis básica es:

tipo nombreVariable = valor;

Ejemplos:

string modelo = "3RT2026-1BB40";
int cantidad = 5;
double precio = 127.50;
bool disponible = true;

3.2 Declaración sin valor inicial

Puedes declarar una variable sin darle valor inmediatamente:

string nombreCliente;
int numeroPedido;
double precioTotal;

// Más adelante en el código...
nombreCliente = "Acme Corp";
numeroPedido = 1001;
precioTotal = 1250.75;

Importante: Si intentas usar una variable sin asignarle valor, C# dará error:

int cantidad;
int total = cantidad * 2;  // ERROR: "Use of unassigned local variable 'cantidad'"

3.3 Múltiples variables del mismo tipo

Puedes declarar varias variables del mismo tipo en una línea:

double voltajeL1, voltajeL2, voltajeL3;
voltajeL1 = 230.0;
voltajeL2 = 232.5;
voltajeL3 = 229.8;

O con valores iniciales:

double voltajeL1 = 230.0, voltajeL2 = 232.5, voltajeL3 = 229.8;

Aunque para legibilidad, generalmente preferimos:

double voltajeL1 = 230.0;
double voltajeL2 = 232.5;
double voltajeL3 = 229.8;

4. Convenciones de nombres (Naming conventions)

Seguir convenciones de nombres hace tu código más legible y profesional.

4.1 Reglas obligatorias (el código no compilará si no las sigues)

Solo letras, números y guión bajo (_)

int valor1;        // OK
int valor_uno;     // OK
int valor-uno;     // ERROR: no se permiten guiones
int valor uno;     // ERROR: no se permiten espacios

Debe comenzar con letra o guión bajo

int numero;        // OK
int _temporal;     // OK
int 1numero;       // ERROR: no puede empezar con número

No puede ser una palabra reservada de C#

int numero;        // OK
int int;           // ERROR: 'int' es palabra reservada
int string;        // ERROR: 'string' es palabra reservada

4.2 Convenciones recomendadas (estilo camelCase para variables)

En C#, las variables locales usan camelCase: primera palabra en minúscula, siguientes palabras con mayúscula inicial.

// Bien (camelCase)
string nombreProyecto;
int numeroPagina;
double voltajeNominal;
bool esCircuitoEmergencia;

// Mal (otros estilos)
string NombreProyecto;        // PascalCase (se usa para clases, no variables)
string nombre_proyecto;       // snake_case (común en Python, no en C#)
string nombreproyecto;        // Difícil de leer

4.3 Nombres descriptivos

Usa nombres que expliquen qué contiene la variable:

// Mal: nombres genéricos
string s;
int n;
double x;

// Bien: nombres descriptivos
string nombreCliente;
int cantidadContactores;
double seccionCable;

Para ingenieros eléctricos, incluye la unidad cuando sea relevante:

double voltajeV;              // Voltaje en Voltios
double corrienteA;            // Corriente en Amperios
double resistenciaOhm;        // Resistencia en Ohmios
double longitudMetros;        // Longitud en metros
double seccionMM2;            // Sección en mm²

O mejor aún, usa nombres claros sin abreviar:

double voltajeLinea;
double corrienteNominal;
double resistenciaTotal;
double longitudCable;
double seccionCable;

5. Conversiones de tipos (Type casting)

A veces necesitas convertir un valor de un tipo a otro.

5.1 Conversión implícita (automática)

C# convierte automáticamente cuando no hay riesgo de perder información:

int numeroPaginas = 10;
double numeroDecimal = numeroPaginas;  // int → double (OK automático)
// numeroDecimal ahora vale 10.0

Jerarquía de conversión implícita:

int → long → float → double

5.2 Conversión explícita (casting)

Cuando vas de un tipo "más grande" a uno "más pequeño", necesitas casting explícito:

double voltajeDecimal = 230.7;
int voltajeEntero = (int)voltajeDecimal;  // double → int
// voltajeEntero = 230 (se trunca el decimal)

Sintaxis: (tipoDestino)variable

Cuidado: Se pierde la parte decimal

double precio = 127.89;
int precioEntero = (int)precio;  // precioEntero = 127 (no 128!)

5.3 Conversión usando métodos Convert

Para conversiones más seguras y controladas:

// De string a números
string textoVoltaje = "230";
int voltaje = Convert.ToInt32(textoVoltaje);

string textoCorriente = "16.5";
double corriente = Convert.ToDouble(textoCorriente);

// De números a string
int cantidad = 42;
string textoAntidad = Convert.ToString(cantidad);
// o más simple:
string textoCantidad2 = cantidad.ToString();

Conversiones comunes:

// String → números
int numero = Convert.ToInt32("123");
double decimal = Convert.ToDouble("45.67");
bool estado = Convert.ToBoolean("true");

// Números → string
string texto1 = Convert.ToString(230);
string texto2 = (16.5).ToString();
string texto3 = true.ToString();  // "True"

5.4 Parse y TryParse

Para convertir strings a números, también puedes usar:

// Parse (genera error si falla)
string texto = "230";
int voltaje = int.Parse(texto);

// TryParse (devuelve true/false si funcionó)
string textoEntrada = "230";
int voltajeResultado;
bool exito = int.TryParse(textoEntrada, out voltajeResultado);

if (exito)
{
    // voltajeResultado contiene 230
}
else
{
    // La conversión falló
}

6. Operaciones básicas con variables

6.1 Operaciones aritméticas

double voltaje = 230.0;
double corriente = 10.5;

// Suma
double suma = voltaje + corriente;  // 240.5

// Resta
double diferencia = voltaje - corriente;  // 219.5

// Multiplicación
double potencia = voltaje * corriente;  // 2415.0 W

// División
double resistencia = voltaje / corriente;  // 21.904... Ω

// Módulo (resto de división)
int totalCables = 100;
int cablesPorBandeja = 12;
int sobran = totalCables % cablesPorBandeja;  // 4

Importante con división de enteros:

int dividendo = 10;
int divisor = 3;
int resultadoEntero = dividendo / divisor;  // 3 (no 3.33!)

double resultadoCorrecto = (double)dividendo / divisor;  // 3.333...

6.2 Concatenación de strings

Unir textos con el operador +:

string nombre = "Motor";
string numero = "M1";
string completo = nombre + " " + numero;  // "Motor M1"

Combinar strings y números:

int cantidad = 5;
string mensaje = "Se encontraron " + cantidad + " errores";
// "Se encontraron 5 errores"

6.3 Formato con string.Format

Para construir strings más complejos:

string cliente = "Acme Corp";
int cantidad = 15;
double precio = 127.50;

string mensaje = string.Format(
    "Cliente: {0}\nCantidad: {1}\nPrecio: ${2:F2}",
    cliente,
    cantidad,
    precio
);
// Resultado:
// Cliente: Acme Corp
// Cantidad: 15
// Precio: $127.50

Placeholders:

{0}, {1}, {2}: posición del argumento
:F2: formato con 2 decimales
\n: salto de línea

Manos a la obra: Construyendo el proyecto

Vamos a crear un script que realiza cálculos eléctricos básicos usando variables.

Paso 1: Estructura básica

using System;
using Eplan.EplApi.Base;
using Eplan.EplApi.ApplicationFramework;

public class CalculadoraCircuitos
{
    [Start]
    public void Ejecutar()
    {
        // Aquí irá nuestro código
    }
}

Paso 2: Declarar variables para un circuito simple

[Start]
public void Ejecutar()
{
    // Datos del circuito
    double voltaje = 230.0;      // Voltios
    double corriente = 16.0;     // Amperios
    double factorPotencia = 0.85;

    string nombreCircuito = "Circuito de Iluminación Planta 2";
    bool esTrifasico = false;
}

¿Qué acabamos de hacer? Declaramos las variables necesarias para un circuito eléctrico básico.

Paso 3: Calcular resistencia (Ley de Ohm)

[Start]
public void Ejecutar()
{
    // Datos del circuito
    double voltaje = 230.0;
    double corriente = 16.0;
    double factorPotencia = 0.85;
    string nombreCircuito = "Circuito de Iluminación Planta 2";
    bool esTrifasico = false;

    // Cálculo 1: Resistencia (R = V / I)
    double resistencia = voltaje / corriente;
}

¿Qué acabamos de hacer? Aplicamos la Ley de Ohm para calcular la resistencia del circuito.

Paso 4: Calcular potencia

// Cálculo 2: Potencia aparente (S = V * I)
double potenciaAparente = voltaje * corriente;

// Cálculo 3: Potencia activa (P = V * I * cos φ)
double potenciaActiva = voltaje * corriente * factorPotencia;

¿Qué acabamos de hacer? Calculamos la potencia aparente y la potencia activa considerando el factor de potencia.

Paso 5: Construir mensaje con resultados

// Construir el mensaje con formato
string mensaje = string.Format(
    "=== CALCULADORA DE CIRCUITOS ===\n\n" +
    "Circuito: {0}\n" +
    "Tipo: {1}\n\n" +
    "DATOS DE ENTRADA:\n" +
    "Voltaje: {2:F1} V\n" +
    "Corriente: {3:F1} A\n" +
    "Factor de potencia: {4:F2}\n\n" +
    "RESULTADOS CALCULADOS:\n" +
    "Resistencia: {5:F2} Ω\n" +
    "Potencia aparente: {6:F2} VA\n" +
    "Potencia activa: {7:F2} W",
    nombreCircuito,
    esTrifasico ? "Trifásico" : "Monofásico",
    voltaje,
    corriente,
    factorPotencia,
    resistencia,
    potenciaAparente,
    potenciaActiva
);

¿Qué acabamos de hacer? Usamos string.Format para construir un mensaje formateado con todos los resultados.

Nota sobre el operador ternario ? ::

esTrifasico ? "Trifásico" : "Monofásico"

Esto significa: "Si esTrifasico es true, usa 'Trifásico', si no, usa 'Monofásico'". Lo veremos en detalle en el Capítulo 5.

Paso 6: Mostrar resultados

// Mostrar en MessageBox
MessageBox.Show(
    mensaje,
    "Calculadora de Circuitos Eléctricos",
    MessageBoxButtons.OK,
    MessageBoxIcon.Information
);

Código completo del proyecto

using System;
using Eplan.EplApi.Base;
using Eplan.EplApi.ApplicationFramework;

public class CalculadoraCircuitos
{
    [Start]
    public void Ejecutar()
    {
        // ========================================
        // DATOS DEL CIRCUITO
        // ========================================

        double voltaje = 230.0;              // Voltios
        double corriente = 16.0;             // Amperios
        double factorPotencia = 0.85;        // cos φ
        string nombreCircuito = "Circuito de Iluminación Planta 2";
        bool esTrifasico = false;

        // ========================================
        // CÁLCULOS
        // ========================================

        // Resistencia usando Ley de Ohm: R = V / I
        double resistencia = voltaje / corriente;

        // Potencia aparente: S = V * I
        double potenciaAparente = voltaje * corriente;

        // Potencia activa: P = V * I * cos φ
        double potenciaActiva = voltaje * corriente * factorPotencia;

        // ========================================
        // CONSTRUCCIÓN DEL MENSAJE
        // ========================================

        string mensaje = string.Format(
            "=== CALCULADORA DE CIRCUITOS ===\n\n" +
            "Circuito: {0}\n" +
            "Tipo: {1}\n\n" +
            "DATOS DE ENTRADA:\n" +
            "Voltaje: {2:F1} V\n" +
            "Corriente: {3:F1} A\n" +
            "Factor de potencia: {4:F2}\n\n" +
            "RESULTADOS CALCULADOS:\n" +
            "Resistencia: {5:F2} Ω\n" +
            "Potencia aparente: {6:F2} VA\n" +
            "Potencia activa: {7:F2} W",
            nombreCircuito,
            esTrifasico ? "Trifásico" : "Monofásico",
            voltaje,
            corriente,
            factorPotencia,
            resistencia,
            potenciaAparente,
            potenciaActiva
        );

        // ========================================
        // MOSTRAR RESULTADOS
        // ========================================

        MessageBox.Show(
            mensaje,
            "Calculadora de Circuitos Eléctricos",
            MessageBoxButtons.OK,
            MessageBoxIcon.Information
        );
    }
}

Ejercicio: Cambia los valores de voltaje, corriente y factorPotencia para probar diferentes circuitos.

Deep Dive: Entendiendo en profundidad

Tipos de datos numéricos adicionales

C# tiene más tipos numéricos para casos específicos:

Enteros de diferentes tamaños:

byte numeroSmall = 255;          // 0 a 255 (8 bits)
short numeroMedio = 32000;       // -32,768 a 32,767 (16 bits)
int numeroNormal = 2000000;      // -2.1B a 2.1B (32 bits)
long numeroGrande = 9000000000L; // -9.2E18 a 9.2E18 (64 bits)

Decimales de diferentes precisiones:

float precisionBaja = 123.45f;      // ~7 dígitos de precisión
double precisionMedia = 123.456789; // ~15-17 dígitos
decimal precisionAlta = 123.456789012345m; // ~28-29 dígitos

¿Cuándo usar cada uno?

int: Para contar cosas (páginas, cables, bornes) - 99% de los casos
double: Para cálculos eléctricos (voltajes, corrientes, resistencias)
decimal: Para cálculos financieros (precios, costos) donde necesitas precisión exacta

El problema de la precisión de punto flotante

Los tipos float y double tienen limitaciones de precisión:

double valor1 = 0.1;
double valor2 = 0.2;
double suma = valor1 + valor2;

// Esperarías: 0.3
// Obtienes: 0.30000000000000004

Solución 1: Redondear cuando sea necesario:

double resultado = Math.Round(suma, 2);  // 0.3

Solución 2: Usar decimal para valores exactos:

decimal precio1 = 0.1m;
decimal precio2 = 0.2m;
decimal precioTotal = precio1 + precio2;  // Exactamente 0.3

Valores por defecto

Si no inicializas una variable de clase, tiene un valor por defecto:

int numero;         // 0
double decimal;     // 0.0
bool estado;        // false
string texto;       // null

Pero en variables locales (dentro de métodos), debes inicializar antes de usar.

Constantes

Para valores que nunca cambian, usa const:

const double PI = 3.14159265359;
const int VOLTAJE_NOMINAL_EU = 230;
const double FRECUENCIA_RED = 50.0;  // Hz en Europa

// Intentar cambiarlas da error:
PI = 3.14;  // ERROR: Cannot assign to a constant

Convención: constantes en MAYÚSCULAS con guiones bajos.

Mejores prácticas

1. Inicializa siempre las variables

// Mal
int contador;
contador++;  // Puede dar error

// Bien
int contador = 0;
contador++;

2. Usa nombres descriptivos

// Mal
double v = 230;
double i = 16;
double p = v * i;

// Bien
double voltaje = 230.0;
double corriente = 16.0;
double potencia = voltaje * corriente;

3. Agrupa variables relacionadas

// Bien organizado
// Datos del circuito
double voltaje = 230.0;
double corriente = 16.0;
double factorPotencia = 0.85;

// Datos del cliente
string nombreCliente = "Acme Corp";
string proyecto = "Planta Nueva";
int numeroPedido = 2025001;

4. Usa el tipo más simple que funcione

// Innecesariamente complejo
decimal cantidadCables = 47m;

// Mejor
int cantidadCables = 47;

Errores comunes

Error 1: Dividir enteros esperando decimal

Síntoma: El resultado de una división es 0 cuando esperabas un decimal.

Causa: Al dividir dos int, el resultado es int (se trunca).

int totalCables = 10;
int bandejas = 3;
int cablesPorBandeja = totalCables / bandejas;  // 3, no 3.33!

Solución: Convierte al menos uno a double:

double cablesPorBandeja = (double)totalCables / bandejas;  // 3.333...

Error 2: Olvidar el sufijo en float/decimal

Síntoma: Error de compilación al asignar un literal.

float valor = 123.45;    // ERROR: Cannot implicitly convert double to float
decimal precio = 99.99;  // ERROR: Cannot implicitly convert double to decimal

Solución: Agrega el sufijo apropiado:

float valor = 123.45f;   // 'f' para float
decimal precio = 99.99m; // 'm' para decimal

Error 3: Usar string sin comillas

Síntoma: Error de compilación.

string nombre = Cliente;  // ERROR: 'Cliente' does not exist

Solución: Texto siempre entre comillas:

string nombre = "Cliente";

Desafíos (Opcional)

Si quieres practicar más, intenta:

Desafío 1: Calculadora de caída de tensión

Dificultad: Bajo

Calcula la caída de tensión en un cable usando:

Fórmula: ΔV = 2 × L × I × ρ / S
L = longitud del cable (metros)
I = corriente (Amperios)
ρ = resistividad del cobre (0.018 Ω·mm²/m)
S = sección del cable (mm²)

Pista

Declara variables para cada parámetro, luego aplica la fórmula directamente.

Solución

using System;
using Eplan.EplApi.Base;
using Eplan.EplApi.ApplicationFramework;

public class CaidaTension
{
    [Start]
    public void Ejecutar()
    {
        // Datos del cable
        double longitudMetros = 50.0;
        double corrienteAmperios = 16.0;
        double seccionMM2 = 2.5;
        double resistividadCobre = 0.018;  // Ω·mm²/m

        // Cálculo de caída de tensión
        double caidaTension = 2 * longitudMetros * corrienteAmperios * resistividadCobre / seccionMM2;

        // Resultado
        string mensaje = string.Format(
            "CÁLCULO DE CAÍDA DE TENSIÓN\n\n" +
            "Longitud: {0} m\n" +
            "Corriente: {1} A\n" +
            "Sección: {2} mm²\n\n" +
            "Caída de tensión: {3:F2} V",
            longitudMetros,
            corrienteAmperios,
            seccionMM2,
            caidaTension
        );

        MessageBox.Show(mensaje, "Caída de Tensión", MessageBoxButtons.OK, MessageBoxIcon.Information);
    }
}

Desafío 2: Convertidor de unidades eléctricas

Dificultad: Bajo

Crea un script que convierta:

kW a HP (caballos de fuerza)
HP a kW
mm² a AWG (aproximado)

Conversiones:

1 HP = 0.746 kW
1 kW = 1.341 HP

Pista

Declara variables para cada valor de entrada, luego multiplica por los factores de conversión.

Conceptos clave para recordar:

Siempre inicializa tus variables
Usa el tipo apropiado para cada dato
Nombres descriptivos hacen el código más legible
La división de enteros trunca el resultado