0Pricing
C# Academy · Lezione

Combinazione con proprietà e tipi base

Inoltri i parametri ai tipi base e alle proprietà.

Combinazione con proprietà e tipi base è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Combinare i costruttori primari con l'ereditarietà

Una classe derivata con un costruttore primario può inoltrare i propri parametri a una classe base usando la sintassi : Base(args) nell'intestazione.

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

Inoltrare un sottoinsieme dei parametri

La classe derivata può accettare più parametri della classe base e passarle solo quelli pertinenti.

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

Trasformare gli argomenti per la classe base

È possibile calcolare gli argomenti del costruttore della classe base a partire dai parametri della classe derivata direttamente nell'intestazione.

using System;

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

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

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

Aggiungere proprietà insieme

Un costruttore primario e le proprietà esplicite possono coesistere. Inizializzi le proprietà a partire dai parametri al momento della dichiarazione.

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

Parametri della classe base e uso nella derivata

Anche dopo averli inoltrati alla classe base, i parametri del costruttore primario della classe derivata possono essere usati nel corpo della classe derivata.

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

Record e costruttori primari

I record usano i costruttori primari per generare automaticamente proprietà pubbliche init-only. Un record posizionale rappresenta il caso più conciso.

using System;

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

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

Ereditarietà dei record

I record derivati inoltrano i parametri posizionali a un record base, generando l'insieme combinato di proprietà.

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

Validazione prima della chiamata alla classe base

Se è necessaria una validazione, la esegua nell'inizializzatore di una proprietà usando un'espressione throw; la chiamata alla classe base viene comunque eseguita per prima.

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

Combinare parametri catturati e proprietà

Può mantenere alcuni parametri come stato privato catturato ed esporne altri come proprietà, personalizzando l'interfaccia pubblica.

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

Valori predefiniti delle proprietà

Le proprietà non associate ai parametri possono comunque avere inizializzatori predefiniti, combinandosi liberamente con i parametri del costruttore 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

Combinare il tutto

Una classe derivata che inoltra i parametri a una classe base, aggiunge una proprietà ed espone un membro calcolato.

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)

Verifica rapida

Verifichi come i costruttori primari inoltrano i parametri alle classi base.

Riepilogo

Ha imparato a combinare i costruttori primari con proprietà e classi base.

  • class D(...) : Base(args) inoltra i parametri alla classe base.
  • Gli argomenti della classe base possono essere calcolati direttamente nell'intestazione.
  • Le proprietà possono essere inizializzate a partire dai parametri al momento della dichiarazione.
  • I record generano proprietà pubbliche init-only a partire dai parametri posizionali.

Domande Frequenti

La lezione «Combinazione con proprietà e tipi base» è gratuita?

Sì — il testo completo di «Combinazione con proprietà e tipi base» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Combinazione con proprietà e tipi base»?

Inoltri i parametri ai tipi base e alle proprietà. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Combinazione con proprietà e tipi base»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Costruttori primari nelle classi
  2. Cattura dei parametri nei membri
  3. Costruttori primari con gli struct
  4. Combinazione con proprietà e tipi base
← Torna a C# Academy