C# Academy · Lección

Combinación con propiedades y tipos base

Transmita parámetros a tipos base y propiedades.

Combinación con propiedades y tipos base es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 4 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.

Combinación de constructores primarios con herencia

Una clase derivada con un constructor primario puede reenviar sus parámetros a una clase base mediante la sintaxis : Base(args) en la cabecera.

using System;

class Animal(string name) {
    public string Name => name;
}

class Dog(string name) : Animal(name) {
    public string Speak() => Name + " says Woof";
}

Console.WriteLine(new Dog("Rex").Speak()); // Rex says Woof

Reenvío de un subconjunto de parámetros

La clase derivada puede aceptar más parámetros que la clase base y pasar únicamente los que sean relevantes.

using System;

class Shape(string color) {
    public string Color => color;
}

class Box(string color, int size) : Shape(color) {
    public int Size => size;
}

var b = new Box("red", 5);
Console.WriteLine(b.Color + " " + b.Size); // red 5

Transformación de argumentos para la clase base

Puede calcular los argumentos del constructor de la clase base a partir de los parámetros derivados directamente en la cabecera.

using System;

class Label(string text) {
    public string Text => text;
}

class UpperLabel(string text) : Label(text.ToUpper()) {
}

Console.WriteLine(new UpperLabel("hi").Text); // HI

Adición de propiedades al mismo tiempo

Un constructor primario y las propiedades explícitas pueden coexistir. Inicialice las propiedades a partir de los parámetros durante la declaración.

using System;

class Product(string name, decimal price) {
    public string Name { get; } = name;
    public decimal Price { get; set; } = price;
}

var p = new Product("Book", 12m);
p.Price = 10m;
Console.WriteLine(p.Name + " " + p.Price); // Book 10

Parámetros de la base y uso en la derivada

Incluso después de reenviarlo a la clase base, un parámetro del constructor primario de la clase derivada puede seguir utilizándose en el cuerpo de esta.

using System;

class Base(int id) {
    public int Id => id;
}

class Item(int id, string label) : Base(id) {
    public string Describe() => "#" + id + ": " + label;
}

Console.WriteLine(new Item(7, "Widget").Describe()); // #7: Widget

Records y constructores primarios

Los records utilizan constructores primarios para generar automáticamente propiedades públicas que solo admiten init. Un record posicional es el caso más conciso.

using System;

record Person(string First, string Last) {
    public string Full => First + " " + Last;
}

Console.WriteLine(new Person("Ada", "Lovelace").Full); // Ada Lovelace

Herencia de records

Los records derivados reenvían sus parámetros posicionalmente a un record base y generan el conjunto combinado de propiedades.

using System;

record Vehicle(string Make);
record Car(string Make, int Doors) : Vehicle(Make);

var c = new Car("Toyota", 4);
Console.WriteLine(c.Make + " " + c.Doors); // Toyota 4

Validación antes de la llamada a la base

Si necesita realizar una validación, hágalo en un inicializador de propiedad mediante una expresión throw; la llamada a la clase base se ejecuta primero.

using System;

class Base(string tag) { public string Tag => tag; }

class Node(string tag) : Base(tag) {
    public string Tag2 { get; } =
        tag.Length > 0 ? tag : throw new ArgumentException("empty");
}

Console.WriteLine(new Node("a").Tag); // a

Combinación de parámetros capturados y propiedades

Puede conservar algunos parámetros como estado privado capturado y exponer otros como propiedades, adaptando así la interfaz pública.

using System;

class Order(int id, decimal total) {
    public decimal Total { get; } = total; // public
    public string Reference() => "ORD-" + id;   // id stays private
}

var o = new Order(42, 99m);
Console.WriteLine(o.Reference() + " " + o.Total); // ORD-42 99

Valores predeterminados de las propiedades

Las propiedades que no estén vinculadas a parámetros también pueden tener inicializadores predeterminados, que se combinan libremente con los parámetros del constructor primario.

using System;

class Session(string user) {
    public string User { get; } = user;
    public bool Active { get; set; } = true;
}

var s = new Session("kai");
Console.WriteLine(s.User + " " + s.Active); // kai True

Integración

Una clase derivada que reenvía parámetros a una clase base, añade una propiedad y expone un miembro calculado.

using System;

class Employee(string name) {
    public string Name => name;
}

class Manager(string name, int teamSize) : Employee(name) {
    public int TeamSize { get; } = teamSize;
    public string Title => Name + " (manages " + TeamSize + ")";
}

Console.WriteLine(new Manager("Sam", 5).Title); // Sam (manages 5)

Comprobación rápida

Confirme cómo los constructores primarios reenvían parámetros a las clases base.

Resumen

Ha aprendido a combinar constructores primarios con propiedades y clases base.

class D(...) : Base(args) reenvía los parámetros a la clase base.
Los argumentos de la clase base se pueden calcular directamente.
Las propiedades se pueden inicializar a partir de los parámetros durante la declaración.
Los records generan propiedades públicas que solo admiten init a partir de parámetros posicionales.

Preguntas frecuentes

¿La lección «Combinación con propiedades y tipos base» es gratis?

Sí — el texto completo de «Combinación con propiedades y tipos base» 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 «Combinación con propiedades y tipos base»?

Transmita parámetros a tipos base y propiedades. 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 4 de 4.

¿Cuánto tiempo toma la lección «Combinación con propiedades y tipos base»?

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