0Pricing
C# Academy · Lección

Constructores primarios en clases

Declare los parámetros del constructor en la cabecera del tipo.

Constructores primarios en clases es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Qué es un constructor principal?

Un constructor principal permite declarar parámetros del constructor directamente en la cabecera de la clase, como class Point(int x, int y). Los parámetros están disponibles en todo el cuerpo de la clase.

using System;

class Point(int x, int y) {
    public int X => x;
    public int Y => y;
}

var p = new Point(3, 4);
Console.WriteLine(p.X + "," + p.Y); // 3,4

Adiós al código repetitivo

Antes de los constructores principales, era necesario escribir el cuerpo de un constructor solo para copiar los parámetros en campos. Ahora la cabecera declara los parámetros y puede hacer referencia a ellos directamente.

using System;

class Greeter(string name) {
    public string Greet() => "Hello, " + name + "!";
}

Console.WriteLine(new Greeter("Ada").Greet()); // Hello, Ada!

Los parámetros están disponibles en todas partes

Los parámetros de un constructor principal pueden utilizarse en inicializadores de propiedades, cuerpos de métodos e inicializadores de campos en cualquier parte de la clase.

using System;

class Circle(double radius) {
    public double Area => Math.PI * radius * radius;
    public double Circumference => 2 * Math.PI * radius;
}

var c = new Circle(2);
Console.WriteLine(Math.Round(c.Area, 2)); // 12.57

Inicializar campos y propiedades

Puede utilizar un parámetro de un constructor principal para inicializar un campo o una propiedad en el momento de su declaración.

using System;

class Account(decimal initial) {
    public decimal Balance { get; private set; } = initial;
    public void Deposit(decimal amount) => Balance += amount;
}

var a = new Account(100m);
a.Deposit(50m);
Console.WriteLine(a.Balance); // 150

Validación en la cabecera

Puede validar parámetros de un constructor principal directamente mediante expresiones throw al asignarlos a un campo.

using System;

class Person(string name) {
    public string Name { get; } =
        string.IsNullOrWhiteSpace(name)
            ? throw new ArgumentException("name required")
            : name;
}

Console.WriteLine(new Person("Lin").Name); // Lin

Agregar constructores adicionales

Una clase con un constructor principal todavía puede declarar constructores adicionales, pero estos deben encadenarse al principal mediante : this(...).

using System;

class Box(int width, int height) {
    public int Width => width;
    public int Height => height;
    public Box(int size) : this(size, size) { }
}

var sq = new Box(5);
Console.WriteLine(sq.Width + "x" + sq.Height); // 5x5

Cuerpos de constructores principales

Los constructores principales no tienen un cuerpo propio. La lógica que deba ejecutarse durante la construcción debe ir en inicializadores de campos o en un constructor normal encadenado.

using System;

class Logger(string prefix) {
    private readonly string tag = "[" + prefix + "]";
    public void Log(string msg) => Console.WriteLine(tag + " " + msg);
}

new Logger("INFO").Log("started"); // [INFO] started

No crean propiedades públicas automáticamente

A diferencia de los registros, un constructor principal en una clase normal no crea propiedades públicas. Los parámetros son privados para la clase, a menos que los exponga explícitamente.

using System;

class Temp(double celsius) {
    // celsius is NOT a public property here
    public double Fahrenheit => celsius * 9 / 5 + 32;
}

Console.WriteLine(new Temp(100).Fahrenheit); // 212

Los parámetros capturados se convierten en campos

Cuando un parámetro de un constructor principal se utiliza en un método (no solo en un inicializador), el compilador lo captura en un campo oculto para que sobreviva a la construcción.

using System;

class Counter(int start) {
    private int value = start;
    public int Next() => value++;
}

var c = new Counter(10);
Console.WriteLine(c.Next()); // 10
Console.WriteLine(c.Next()); // 11

Inyección de dependencias más sencilla

Los constructores principales son populares para la inyección de dependencias: declare los servicios en la cabecera y utilícelos en los métodos, sin asignar campos manualmente.

using System;

interface IClock { string Now(); }
class FakeClock : IClock { public string Now() => "12:00"; }

class Service(IClock clock) {
    public string Report() => "Time is " + clock.Now();
}

Console.WriteLine(new Service(new FakeClock()).Report()); // Time is 12:00

Unir todos los conceptos

Esta clase utiliza un constructor principal para sus dependencias y expone una propiedad calculada, sin un cuerpo de constructor explícito.

using System;

class Rectangle(double w, double h) {
    public double Area => w * h;
    public double Perimeter => 2 * (w + h);
}

var r = new Rectangle(3, 4);
Console.WriteLine(r.Area + " " + r.Perimeter); // 12 14

Comprobación rápida

Compruebe su comprensión de los constructores principales en las clases.

Resumen

Ha aprendido a utilizar constructores principales en clases.

  • class C(int x) declara los parámetros del constructor en la cabecera.
  • Los parámetros están disponibles en todo el cuerpo de la clase.
  • Los constructores adicionales se encadenan mediante : this(...).
  • En una clase normal, no se convierten automáticamente en propiedades públicas.

Preguntas frecuentes

¿La lección «Constructores primarios en clases» es gratis?

Sí — el texto completo de «Constructores primarios en clases» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Constructores primarios en clases»?

Declare los parámetros del constructor en la cabecera del tipo. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Constructores primarios en clases»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Constructores primarios en clases
  2. Captura de parámetros en miembros
  3. Constructores primarios con structs
  4. Combinación con propiedades y tipos base
← Volver a C# Academy