Capítulo 3: Variables y tipos de datos

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

//
// Proyecto: Calculadora de Circuitos Básicos
// Capítulo: 3
// Descripción: Calcula resistencia y potencia de un circuito usando variables
// Autor: C.D. López
// Fecha: Enero 2025
//

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
        );
    }
}

Cómo probar el script:

Guarda el código en: X:\Scripts\v6.0\CalculadoraCircuitos.cs
En EPLAN: Utilidades → Scripts → Ejecutar script
Selecciona el archivo
Verás un cuadro de diálogo con todos los cálculos

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: ⭐☆☆

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: ⭐⭐☆

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.

Desafío 3: Calculadora trifásica completa

Dificultad: ⭐⭐⭐

Crea un script que calcule para un sistema trifásico:

Potencia trifásica: P = √3 × V × I × cos φ
Corriente por fase
Potencia por fase
Factor de potencia requerido para alcanzar una potencia objetivo

Pista

Usa Math.Sqrt(3) para la raíz cuadrada de 3.

📝 Resumen

En este capítulo aprendiste:

✅ Qué es una variable: Un contenedor con nombre para almacenar valores
✅ Tipos básicos: string (texto), int (enteros), double (decimales), bool (verdadero/falso)
✅ Declaración: tipo nombreVariable = valor;
✅ Convenciones: camelCase para variables, nombres descriptivos
✅ Conversiones: Implícitas (automáticas) y explícitas (casting)
✅ Operaciones: Aritméticas básicas y concatenación de strings
✅ Proyecto construido: Calculadora de circuitos eléctricos básicos

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

🔗 Conexiones

⬅️ Capítulo anterior

Capítulo 2: Tu entorno de trabajo

➡️ Próximo capítulo

Capítulo 4: Operaciones y expresiones

En el próximo capítulo profundizaremos en operaciones matemáticas más complejas, operadores de comparación, operadores lógicos, y cómo combinarlos en expresiones. Aprenderás a construir fórmulas complejas para tus cálculos eléctricos.

📚 Recursos adicionales

📖 Documentación de C# - Tipos de datos
💻 [Código completo]: code/cap-03/

❓ Preguntas frecuentes

P: ¿Por qué usar double en vez de float para cálculos eléctricos?

R: double tiene el doble de precisión que float (15-17 dígitos vs 7 dígitos). Para cálculos eléctricos donde la precisión importa, double es la opción estándar. Además, es el tipo por defecto en C# para literales decimales.

P: ¿Cuándo debo usar decimal en vez de double?

R: Usa decimal para cálculos financieros (precios, costos, presupuestos) donde necesitas precisión exacta. Para cálculos de ingeniería (voltajes, corrientes, resistencias), double es suficiente y más eficiente.

P: ¿Puedo cambiar el tipo de una variable después de declararla?

R: No. C# es fuertemente tipado. Una vez que declaras int numero, esa variable siempre será int. Si necesitas otro tipo, debes declarar una nueva variable.

P: ¿Por qué mi división de enteros da 0?

R: Porque al dividir dos int, el resultado es int y se trunca. Solución: convierte al menos uno a double antes de dividir: (double)dividendo / divisor.

P: ¿Importa si uso 230 o 230.0 para un double?

R: Funcionalmente no, pero 230.0 es más claro y explícito. Es una buena práctica usar .0 para indicar que es un número decimal.

📋 Checklist de completitud

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

Entender qué es una variable y para qué sirve
Poder declarar variables de tipo string, int, double y bool
Conocer las convenciones de nombres (camelCase)
Saber hacer conversiones básicas entre tipos
Haber ejecutado exitosamente el script CalculadoraCircuitos
Poder modificar los valores de entrada y ver resultados diferentes
Entender cómo usar string.Format para mensajes formateados
(Opcional) Haber intentado al menos un desafío

¿Listo para continuar? Vamos al Capítulo 4! 🚀

Última actualización: Enero 2025 Tiempo de lectura estimado: 35-40 minutos Código de ejemplo: code/cap-03/

📂 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)