Sintaxis de declaración de clase y su estructura

1. Estructura general de la declaración de una clase

Imagínate esto: una clase en C# es como el plano de un edificio. En el plano describes cuántas habitaciones hay, de qué color son las paredes, dónde están las puertas y ventanas. En la clase — qué propiedades tiene el objeto (por ejemplo, nombre, edad) y qué puede hacer (por ejemplo, "saludar", "pedir salario").

La declaración de una clase siempre tiene tres bloques principales:

1. Modificador de acceso (public, private, internal, protected) — quién puede usar esta clase. Para no liarnos, ahora vamos a usar public, para que la clase sea "visible" en todas partes.
2. La palabra clave class — para que el compilador entienda que de verdad estamos describiendo una clase.
3. Nombre de la clase — con mayúscula, por convención.
4. El cuerpo de la clase entre llaves — aquí describes todo lo que compone tu clase: campos, propiedades, métodos.

Esquemáticamente se ve así:

public class NombreDeLaClase
{
    // Aquí van los campos, propiedades y métodos de la clase
}

Ejemplo: Clase de estudiante

public class Student
{
    // Campos (variables que pertenecen al objeto)
    public string Name;
    public int Age;
}

Por ahora esta clase es como una caja vacía: hemos descrito que un estudiante tiene nombre y edad, pero todavía no le hemos enseñado nada.

2. Campos de la clase (fields)

Campos — son variables que pertenecen al objeto de la clase. Por ejemplo, cada estudiante debe tener su propio nombre y edad — por eso se describen como campos:

public class Student
{
    public string Name;
    public int Age;
}

Ahora, cuando creas un objeto de tipo Student, cada objeto tendrá su propio nombre y edad.

Ejemplo de creación de objeto:

Student sasha = new Student();
sasha.Name = "Sasha";
sasha.Age = 20;

Aquí hemos creado el objeto sasha, y luego le asignamos valores a sus campos. Este enfoque se usa para empezar de la forma más simple (sobre constructores hablaremos en detalle en la próxima lección).

3. Métodos de la clase (functions)

Los métodos son los "verbos" del objeto, o sea, su comportamiento. Las acciones que puede realizar. Por ejemplo, un estudiante puede saludar. Para eso se describe un método dentro de la clase:

public class Student
{
    public string Name;
    public int Age;

    public void SayHello()
    {
        Console.WriteLine($"¡Hola, me llamo {Name}, tengo {Age} años!");
    }
}

Ahora cada estudiante puede "saludar" — y usará su propio nombre y edad.

Ejemplo de uso del método:

Student sasha = new Student();
sasha.Name = "Sasha";
sasha.Age = 20;
sasha.SayHello(); // Mostrará: ¡Hola, me llamo Sasha, tengo 20 años!

4. Propiedades de la clase (properties)

Propiedades — son "campos inteligentes", a los que puedes añadir acciones especiales al leer o escribir el valor. En el C# moderno se usan propiedades más a menudo que campos, porque dan más control y flexibilidad. Es como la electricidad: parece simple, pero tiene un montón de posibilidades.

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Aquí get; set; crea automáticamente el campo, pero te permite añadir lógica cuando cambias el valor en el futuro. Para el usuario de la clase, las propiedades se ven casi igual que los campos.

Ejemplo:

Student katya = new Student();
katya.Name = "Katya";
katya.Age = 18;
Console.WriteLine(katya.Name); // Katya

Más sobre propiedades de clase — en las próximas lecciones :P

5. Comentarios

¡Tema aburrido pero importante! Igual que en el resto del código, dentro de la clase puedes (y debes) escribir comentarios para explicar para qué sirve cada campo o método:

public class Student
{
    // Nombre del estudiante
    public string Name { get; set; }
    
    // Edad del estudiante (en años)
    public int Age { get; set; }

    // El estudiante saluda
    public void SayHello()
    {
        Console.WriteLine($"¡Hola, me llamo {Name}, tengo {Age} años!");
    }
}

Esto mejora la legibilidad y ayuda a no perderte incluso en un proyecto grande.

6. Modificadores de acceso

Los modificadores de acceso — son como puertas con diferentes cerraduras. Definen quién y desde dónde puede acceder a los miembros de la clase. Los principales modificadores:

• public: accesible en todas partes (nuestro caso por defecto).
• private: accesible solo dentro de esta clase.
• internal: accesible dentro del ensamblado actual (proyectos, librerías).
• protected: accesible dentro de la clase y sus herederos.

Ejemplo de un campo que está oculto del mundo exterior:

public class Student
{
    private int age; // Solo dentro de Student
    public string Name { get; set; }

    public void SetAge(int value)
    {
        if (value > 0)
            age = value;
    }

    public int GetAge()
    {
        return age;
    }
}

Al principio, a menudo todos los miembros se declaran public para no liarse, pero en proyectos reales eso es mala práctica: algunos detalles de implementación es mejor ocultarlos.

7. Miembros estáticos de la clase

A veces una clase tiene datos o métodos que no pertenecen a un objeto concreto, sino a toda la clase. Estos son los miembros estáticos (static members).

Por ejemplo: queremos llevar un contador general de estudiantes.

public class Student
{
    public static int StudentsCount = 0;

    public string Name { get; set; }
    public int Age { get; set; }
}

El acceso al miembro estático se hace usando el nombre de la clase:

Student.StudentsCount = 0;

Cada objeto tiene sus propias propiedades/campos, pero los estáticos — son comunes para todos. En el ejemplo de arriba, si tenemos 10 estudiantes, cada uno tiene su propio Name, pero StudentsCount — es uno solo para todos.

8. Ejemplo: Clase completa de estudiante (versión con métodos)

Vamos a juntar todo y crear una clase de estudiante que lo hace todo y está bien hecha:

public class Student
{
    // Contador estático de estudiantes - pertenece a todos los estudiantes
    public static int Count = 0;

    // Nombre y edad - propiedades
    public string Name { get; set; }
    public int Age { get; set; }

    // Constructor (sobre constructores — en la próxima lección)
    public Student(string name, int age)
    {
        Name = name;
        Age = age;
        Count++; // Cada vez que se crea un objeto, aumentamos el contador
    }

    // Método para saludar
    public void SayHello()
    {
        Console.WriteLine($"¡Hola! Soy {Name}. Tengo {Age} años.");
    }
}

Uso en la aplicación principal:

class Program
{
    static void Main()
    {
        Student sasha = new Student("Sasha", 20);
        Student katya = new Student("Katya", 22);

        sasha.SayHello();
        katya.SayHello();

        Console.WriteLine($"Total de estudiantes: {Student.Count}");
    }
}

9. Organización del código: un archivo = una clase

En .NET es costumbre poner cada clase pública en un archivo separado con el mismo nombre que la clase. Por ejemplo:

Student.cs
|
|__ public class Student

Y en el archivo principal del programa (Program.cs) — el punto de entrada y el código principal. Esto facilita navegar por el proyecto, sobre todo cuando tienes muchas clases.

10. Errores típicos al trabajar con clases y objetos

Error nº1: olvidaste las llaves o las pusiste mal.
El compilador te dará un error enseguida, pero no siempre está claro dónde está el problema. Sobre todo si las llaves se han perdido en una construcción larga — encontrar dónde se rompió todo puede ser complicado.

Error nº2: declaraste dos clases con el mismo nombre en el mismo namespace.
El compilador no va a aceptar ese "arte". Y mejor así — si no, ni tú sabrías a qué clase te refieres.

Error nº3: le diste al campo el mismo nombre que a la propiedad.
Esto crea confusión al acceder a los miembros de la clase. Incluso los desarrolladores con experiencia a veces se tiran de los pelos: "¿Estoy accediendo al campo o a la propiedad?"

Error nº4: no pusiste modificador de acceso.
Por defecto la clase se vuelve internal, y si estás escribiendo una librería — esto puede limitar el acceso a la clase desde fuera sin que te des cuenta.

Error nº5: acceso a miembros estáticos a través de una instancia.
Si escribes student.Count en vez de Student.Count, el compilador puede que no lo prohíba, pero confunde bastante. Así parece que Count pertenece a un estudiante concreto, pero en realidad — es de todos.