C# Academy · Lezione

Cattura dei parametri nei membri

Utilizzi i parametri del costruttore primario in tutto il tipo.

Cattura dei parametri nei membri è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Usare i parametri nei membri

Il punto di forza dei costruttori primari consiste nell'usare i parametri all'interno dei membri: metodi, proprietà e inizializzatori di campi. Il compilatore gestisce l'archiviazione come necessario.

using System;

class Multiplier(int factor) {
    public int Apply(int n) => n * factor;
}

Console.WriteLine(new Multiplier(3).Apply(5)); // 15

Acquisizione e utilizzo solo nell'inizializzatore

Se un parametro viene usato solo nell'inizializzatore di un campo o di una proprietà, non è necessaria memoria aggiuntiva. Se viene usato in un metodo, il compilatore lo acquisisce in un campo nascosto.

using System;

class A(int x) {
    public int Stored = x;     // initializer only
}
class B(int x) {
    public int Get() => x;     // captured into a field
}

Console.WriteLine(new A(7).Stored); // 7
Console.WriteLine(new B(9).Get());  // 9

I parametri sono modificabili

I parametri del costruttore primario si comportano come normali parametri: sono modificabili all'interno dell'istanza, a meno che non vengano trattati come di sola lettura. Modificarne uno cambia il campo acquisito.

using System;

class Toggle(bool on) {
    public void Flip() => on = !on;
    public bool State => on;
}

var t = new Toggle(false);
t.Flip();
Console.WriteLine(t.State); // True

Esporre proprietà di sola lettura

Un modello comune consiste nell'esporre un parametro tramite una proprietà con il solo getter, ottenendo un'interfaccia pubblica pulita e mantenendo il parametro interno.

using System;

class User(string email) {
    public string Email { get; } = email;
}

Console.WriteLine(new User("a@b.com").Email); // a@b.com

Proprietà calcolate a partire dai parametri

I parametri si prestano naturalmente alle proprietà calcolate con corpo espressione.

using System;

class Money(decimal amount, string currency) {
    public string Display => amount.ToString("0.00") + " " + currency;
}

Console.WriteLine(new Money(9.5m, "USD").Display); // 9.50 USD

Parametri in più metodi

Lo stesso parametro acquisito può essere condiviso da più metodi, comportandosi come un campo privato inizializzato durante la costruzione.

using System;

class Range2(int lo, int hi) {
    public bool Contains(int n) => n >= lo && n <= hi;
    public int Clamp(int n) => Math.Max(lo, Math.Min(hi, n));
}

var r = new Range2(0, 10);
Console.WriteLine(r.Contains(5)); // True
Console.WriteLine(r.Clamp(15));   // 10

Catturare i tipi riferimento

I parametri catturati di tipo riferimento consentono di memorizzare le dipendenze iniettate e di utilizzarle da qualsiasi metodo.

using System;
using System.Collections.Generic;

class Repo(List<string> store) {
    public void Add(string item) => store.Add(item);
    public int Count => store.Count;
}

var list = new List<string>();
var repo = new Repo(list);
repo.Add("x");
Console.WriteLine(repo.Count); // 1

Evitare la doppia memorizzazione accidentale

Se assegna un parametro a un campo e usa anche il parametro nei metodi, potrebbe finire per memorizzare il valore due volte. Per maggiore chiarezza, preferisca un solo approccio.

using System;

class Clean(int x) {
    // expose once via property, reference property in methods
    public int Value { get; } = x;
    public int Doubled() => Value * 2;
}

Console.WriteLine(new Clean(4).Doubled()); // 8

Parametri nelle lambda

I parametri possono essere catturati dalle lambda definite all'interno della classe, proprio come i campi.

using System;
using System.Collections.Generic;
using System.Linq;

class Filter(int threshold) {
    public IEnumerable<int> KeepAbove(IEnumerable<int> xs) =>
        xs.Where(n => n > threshold);
}

var f = new Filter(3);
Console.WriteLine(string.Join(",", f.KeepAbove(new[]{1,2,3,4,5}))); // 4,5

Durata dell'ambito

Un parametro catturato vive per tutta la durata dell'oggetto. Di fatto rappresenta lo stato dell'istanza, quindi non presuma che venga reimpostato tra una chiamata al metodo e l'altra.

using System;

class Accumulator(int seed) {
    private int total = seed;
    public int Add(int n) { total += n; return total; }
}

var a = new Accumulator(100);
Console.WriteLine(a.Add(1)); // 101
Console.WriteLine(a.Add(1)); // 102

Combinare il tutto

Questo servizio cattura due dipendenze e le usa in più metodi, mostrando la struttura tipica di un caso reale.

using System;

class PriceService(decimal taxRate, string currency) {
    public decimal WithTax(decimal net) => net * (1 + taxRate);
    public string Format(decimal v) => v.ToString("0.00") + " " + currency;
}

var s = new PriceService(0.2m, "EUR");
Console.WriteLine(s.Format(s.WithTax(100m))); // 120.00 EUR

Verifica rapida

Verifichi come vengono memorizzati i parametri dei costruttori primari.

Riepilogo

Ha imparato come vengono usati i parametri dei costruttori primari nei membri.

Quando vengono usati nei metodi, i parametri vengono catturati in campi nascosti.
Se vengono usati solo negli inizializzatori, non è necessaria alcuna memoria aggiuntiva.
Li esponga tramite proprietà con il solo accessor get per ottenere un'interfaccia pulita.
Si comportano come stato dell'istanza per tutta la durata dell'oggetto.

Domande Frequenti

La lezione «Cattura dei parametri nei membri» è gratuita?

Sì — il testo completo di «Cattura dei parametri nei membri» è 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 «Cattura dei parametri nei membri»?

Utilizzi i parametri del costruttore primario in tutto il tipo. 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 2 di 4.

Quanto tempo richiede la lezione «Cattura dei parametri nei membri»?

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

← Torna a C# Academy