C# Academy · Lección

Constructores primarios con structs

Aplique constructores primarios a tipos de valor.

Constructores primarios con structs es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 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.

Constructores primarios en structs

Los structs también admiten constructores primarios: struct Point(int x, int y). Funcionan de forma muy similar a los de las clases, ya que declaran los parámetros en la cabecera.

using System;

struct 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

El constructor sin parámetros sigue existiendo

Los structs siempre tienen un constructor implícito sin parámetros que produce el valor predeterminado. Un constructor primario añade otro parametrizado junto a él.

using System;

struct Vec(int x, int y) {
    public int X => x;
    public int Y => y;
}

var zero = new Vec(); // default: x=0, y=0
Console.WriteLine(zero.X + "," + zero.Y); // 0,0

Exposición de parámetros mediante propiedades

Al igual que en las clases, los parámetros de los constructores primarios de los structs no se convierten automáticamente en propiedades públicas; debe exponerlos explícitamente.

using System;

struct Size(int w, int h) {
    public int Width { get; } = w;
    public int Height { get; } = h;
}

var s = new Size(10, 20);
Console.WriteLine(s.Width * s.Height); // 200

Miembros calculados

Los constructores primarios de los structs combinan especialmente bien con miembros calculados cuyo cuerpo es una expresión.

using System;

struct Complex(double re, double im) {
    public double Magnitude => Math.Sqrt(re * re + im * im);
}

Console.WriteLine(new Complex(3, 4).Magnitude); // 5

Structs de solo lectura

Un readonly struct con un constructor primario garantiza la inmutabilidad. Ningún miembro debe modificar el estado, lo que encaja perfectamente con las propiedades de solo lectura.

using System;

readonly struct Money(decimal amount, string currency) {
    public decimal Amount { get; } = amount;
    public string Currency { get; } = currency;
    public string Display => Amount.ToString("0.00") + " " + Currency;
}

Console.WriteLine(new Money(5m, "USD").Display); // 5.00 USD

Encadenamiento con el constructor primario

Los constructores adicionales de un struct deben llamar al constructor primario mediante : this(...), igual que en las clases.

using System;

struct Square(int side) {
    public int Side => side;
    public int Area => side * side;
    public Square() : this(1) { } // explicit default side
}

Console.WriteLine(new Square(4).Area); // 16

Constructor predeterminado frente al primario

Tenga en cuenta que new Square() puede utilizar tanto la inicialización implícita con ceros como el constructor sin parámetros que haya declarado. Si define uno que se encadene, se ejecutará su lógica.

using System;

struct Pct(double value) {
    public double Value { get; } = value;
    public Pct() : this(100) { }
}

Console.WriteLine(new Pct().Value); // 100

La semántica de valor se mantiene

Los structs siguen copiándose por valor. Un constructor primario no cambia este comportamiento: al asignar un struct, se copian todos sus campos.

using System;

struct Counter(int n) {
    public int N { get; set; } = n;
}

var a = new Counter(1);
var b = a;       // copy
b.N = 99;
Console.WriteLine(a.N + " " + b.N); // 1 99

Inicialización de campos mutables

Puede inicializar propiedades o campos modificables a partir de los parámetros, aunque normalmente es preferible utilizar structs inmutables.

using System;

struct Bag(int capacity) {
    public int Capacity { get; set; } = capacity;
    public int Used { get; set; } = 0;
}

var bag = new Bag(10);
bag.Used = 3;
Console.WriteLine(bag.Capacity - bag.Used); // 7

Deconstrucción

Combine un constructor primario con un método Deconstruct para obtener una desempaquetación similar a la de las tuplas.

using System;

struct Point(int x, int y) {
    public int X => x;
    public int Y => y;
    public void Deconstruct(out int a, out int b) { a = x; b = y; }
}

var (px, py) = new Point(7, 8);
Console.WriteLine(px + "," + py); // 7,8

Integración

Un pequeño tipo de valor inmutable creado con un readonly struct y un constructor primario.

using System;

readonly struct Temperature(double celsius) {
    public double Celsius { get; } = celsius;
    public double Fahrenheit => Celsius * 9 / 5 + 32;
}

var t = new Temperature(25);
Console.WriteLine(t.Fahrenheit); // 77

Comprobación rápida

Compruebe cuánto domina los constructores primarios en los structs.

Resumen

Ha aprendido a utilizar constructores primarios en structs.

struct P(int x, int y) declara los parámetros en la cabecera.
El constructor implícito sin parámetros sigue existiendo.
Combínelo con readonly struct para crear tipos de valor inmutables.
Los constructores adicionales se encadenan mediante : this(...).

Preguntas frecuentes

¿La lección «Constructores primarios con structs» es gratis?

Sí — el texto completo de «Constructores primarios con structs» 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 con structs»?

Aplique constructores primarios a tipos de valor. 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 3 de 4.

¿Cuánto tiempo toma la lección «Constructores primarios con structs»?

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

Constructores primarios en clases
Captura de parámetros en miembros
Constructores primarios con structs
Combinación con propiedades y tipos base

← Volver a C# Academy