1. El programa — como una oficina llena de departamentos
Cuando recién empiezas a programar, parece que puedes escribir el código línea por línea y todo va a funcionar. Pero en cuanto el programa se complica un poco, empieza el lío mental: ¿dónde está cada cosa, para qué se escribió esto, y si hay que cambiar una línea — ¿dónde narices está?..
Por eso C#, igual que la mayoría de lenguajes modernos, nos da una forma de “poner” el código en estanterías, para que siempre puedas entender qué hace el programa y encontrar rápido lo que buscas.
Imagínate una empresa. Tiene recursos humanos, contabilidad, IT, logística y así. Cada departamento tiene su zona de responsabilidad, su gente y sus tareas.
En un programa en C# cada “departamento” es una clase. Una clase se encarga, por ejemplo, de los usuarios, otra de los cálculos, otra de los archivos.
Así se ve la estructura típica de un proyecto sencillo:
- Program.cs — la oficina principal: aquí está el “punto de entrada”, donde todo empieza.
- User.cs — el departamento donde se guardan y procesan los datos del usuario.
- Calculator.cs — el departamento de cálculos.
- FileHelper.cs — los especialistas en archivos.
Incluso en un programa pequeñito suele haber al menos una clase. ¡Y los proyectos grandes son ya un “rascacielos” de cientos de clases!
2. Una clase — es una caja de herramientas
C# es un lenguaje orientado a objetos y todo en él son objetos. Los tipos de objetos se llaman clases.
Una clase es como una caja o un armario donde metemos las cosas que necesitamos: variables, métodos, propiedades. Imagina una caja con la etiqueta “Martillos”: dentro solo hay herramientas relacionadas con martillos.
class Example
{
// Aquí van nuestras herramientas: variables, métodos, propiedades
}Las clases normalmente tienen variables y funciones. En C# a las variables de clase se les suele llamar campos, y a las funciones de clase — métodos. Pero el sentido es el mismo.
¿Recuerdas nuestro primer código?
Console.WriteLine("¡Hola a todos!");
string name = Console.ReadLine();
En este código hay clase y métodos:
- Console — es una clase que tiene métodos (funciones) para trabajar con la consola.
- WriteLine — es un método de la clase Console que muestra texto en pantalla.
- ReadLine — es un método de la clase Console que lee la entrada del teclado.
Toda la programación, en cierto modo, se reduce a escribir tus propias clases y métodos, que llaman a métodos de otras clases.
3. Campos (variables) de clase — es su memoria
Dentro de una clase puedes guardar variables (a menudo llamadas “campos”). Son como celdas de memoria donde guardamos datos.
class Counter
{
int value; // campo — aquí se guarda el valor actual del contador Counter
}Los campos permiten que la clase recuerde cosas entre llamadas a diferentes métodos. Por ejemplo, contar cuántas veces se ha pulsado un botón.
Puede haber tantos campos como quieras. Ejemplo:
class User
{
int id; // número único de usuario
string name; // nombre del usuario
int age; // edad
string adress; // dirección
User[] children; // hijos
}
4. Métodos — acciones que puede hacer la clase
Los métodos son las “habilidades” de nuestra clase. Si la clase es un empleado, los métodos son sus skills: lo que sabe hacer.
- Un método puede mostrar algo en pantalla.
- Calcular la suma de dos números.
- Recibir datos “de entrada” y devolver un resultado.
Estructura de un método:
- Tipo de valor que devuelve (por ejemplo, void — si no devuelve nada, o int — si devuelve un número)
- Nombre del método (por ejemplo, Print)
- Parámetros entre paréntesis (puede estar vacío)
- Llaves { ... } — el cuerpo del método
class Printer
{
public void PrintHello()
{
Console.WriteLine("¡Hola!");
}
public int Add(int a, int b)
{
return a + b;
}
}Más detalles sobre métodos y todos sus matices los veremos en las próximas lecciones.
5. Propiedades — variables inteligentes
Una propiedad (property) es como una variable “mejorada”: no solo guarda un valor, sino que puede hacer algo cuando se obtiene o se cambia el valor.
Ejemplo de la vida real: no puedes simplemente cambiar el sueldo de un empleado — el contable comprobará si todo está bien. Así una propiedad puede “comprobar” los datos:
class Person
{
private int age; // variable (campo) de la clase
public int Age // propiedad Age. guarda datos en la variable de clase age.
{
get { return age; } // método get - se llama cuando alguien intenta obtener el valor de Age
set // método Set - se llama cuando alguien intenta cambiar el valor de Age
{
if (value >= 0)
age = value;
}
}
}
El código en el método set no dejará poner una edad negativa. Veremos las propiedades en detalle en las próximas lecciones.
6. Modificadores de acceso
En C# puedes decidir qué partes de la clase son accesibles desde otras clases y cuáles quedan solo para uso interno. Para eso se usan los modificadores de acceso. Si delante del nombre de un campo, método o clase está la palabra clave public, puedes acceder a él desde cualquier parte del programa.
Si delante del nombre de un campo, método o clase está la palabra clave private, solo puedes acceder a él desde su propia clase. Las demás clases no lo ven. Como si no existiera.
- public — lo ven todos. Estos métodos y propiedades se pueden usar desde otras clases.
- private — solo se ve dentro de la propia clase. Son detalles internos que no deberían estar accesibles para otros.
class Demo
{
public int OpenValue; // visible desde fuera
private int secretValue; // solo visible dentro
public void ShowOpen() { Console.WriteLine(OpenValue); }
private void HideSecret() { Console.WriteLine(secretValue); }
}
Regla de oro: los campos suelen ser private, y solo se “sacan” hacia fuera los métodos y propiedades necesarios (public).
7. Cómo se ve una clase real
Aquí tienes un ejemplo “montado” — una mini calculadora:
class Calculator
{
private int result; // campo para guardar el resultado
public int Result
{
get { return result; }
private set { result = value; } // acceso solo dentro de la clase
}
public void Add(int a, int b)
{
result = a + b;
}
public void Clear()
{
result = 0;
}
}
¡Este enfoque lo vas a ver en casi todos los programas modernos en C#!
8. Top-level statements
En realidad, en C# todo el código siempre está dentro de clases. La clase es la unidad mínima del programa. Puede haber muchas clases, pero como mínimo — una.
Un momento, ¿y todo ese código que acabamos de escribir, si ahí no había ninguna clase?
Eso es una de las cosas modernas de C#: puedes escribir código sin clase, y el compilador de C# lo convierte automáticamente en una clase.
Por ejemplo, tienes este código en Program.cs:
// tu código
WriteSmile();
WriteSmile();
WriteSmile();
//tu propia función
void WriteSmile()
{
Console.WriteLine(":)");
}El compilador de C# lo transforma así:
using System;
class Program
{
static void Main() // tu código
{
WriteSmile();
WriteSmile();
WriteSmile();
}
static void WriteSmile() //tu propia función
{
Console.WriteLine(":)");
}
}Si solo pillaste la mitad de la lección, no pasa nada: lo importante es que te quedes con la idea general. En las próximas lecciones vamos a ver paso a paso todo lo que aquí se ha contado.
GO TO FULL VERSION