Incapsulamento e invarianti
Nasconda lo stato interno, esponga operazioni sicure e mantenga valide le invarianti della classe (ad esempio saldo non negativo e intervalli validi).
Incapsulamento e invarianti è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 di 3. 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 3 lezioni in totale.
Panoramica sull'incapsulamento
Obiettivo: Proteggere lo stato dell'oggetto.
- Incapsulamento: nascondere i campi ed esporre API sicure
- Invariante: una regola sempre vera
- Convalidare nei costruttori, nei setter e nei metodi
Interfaccia di sola lettura
Mantenga i campi privati. Fornisca ai chiamanti una proprietà di sola lettura e operazioni sicure.
using System;
// Expose read-only view; mutate via methods only
public class Counter
{
private int _value; // hidden state
public int Value // read-only to callers
{
get { return _value; }
private set { _value = value; } // keep setter private
}
public void Increment()
{
Value = Value + 1;
}
}
public class Program
{
public static void Main(string[] args)
{
Counter c = new Counter();
c.Increment();
c.Increment();
Console.WriteLine("Value = " + c.Value);
}
}
Controlli nei costruttori
I costruttori impostano lo stato obbligatorio. Verifichi che gli input siano validi, così gli oggetti saranno validi fin dall'inizio.
using System;
// Enforce rules early (constructor guard)
public class User
{
public string Name { get; private set; }
public int Age { get; private set; }
public User(string name, int age)
{
if (string.IsNullOrEmpty(name)) throw new ArgumentException("name");
if (age < 0) throw new ArgumentOutOfRangeException("age");
Name = name;
Age = age;
}
}
public class Program
{
public static void Main(string[] args)
{
try
{
User u = new User("Ada", 28);
Console.WriteLine(u.Name + " (" + u.Age + ")");
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
}
}
L'invariante nella pratica
Definisca un'invariante (ad esempio, Balance ≥ 0) e la faccia rispettare nei setter e nei metodi.
using System;
// Invariant: Balance >= 0 at all times
public class BankAccount
{
private decimal _balance;
public decimal Balance
{
get { return _balance; }
private set
{
if (value < 0) throw new InvalidOperationException("Balance would be negative");
_balance = value;
}
}
public BankAccount(decimal opening)
{
if (opening < 0) throw new ArgumentOutOfRangeException("opening");
_balance = opening;
}
public void Deposit(decimal amount)
{
if (amount <= 0) throw new ArgumentOutOfRangeException("amount");
Balance = Balance + amount;
}
public bool TryWithdraw(decimal amount)
{
if (amount <= 0) return false;
if (Balance - amount < 0) return false;
Balance = Balance - amount;
return true;
}
}
public class Program
{
public static void Main(string[] args)
{
BankAccount a = new BankAccount(50m);
a.Deposit(20m);
bool ok = a.TryWithdraw(100m); // fails, invariant protected
Console.WriteLine("ok=" + ok + " balance=" + a.Balance);
}
}
Proteggere le raccolte
Non esponga direttamente gli elenchi o gli array interni. Restituisca una copia (o una vista di sola lettura) per proteggere gli invarianti.
using System;
using System.Collections.Generic;
public class Tags
{
private readonly List<string> _items = new List<string>();
public void Add(string tag)
{
if (string.IsNullOrWhiteSpace(tag)) return;
_items.Add(tag.Trim());
}
// Expose a copy so callers cannot mutate internal list
public List<string> GetAllCopy()
{
return new List<string>(_items);
}
}
public class Program
{
public static void Main(string[] args)
{
Tags t = new Tags();
t.Add(" apple ");
t.Add("banana");
List<string> view = t.GetAllCopy();
view.Add("hacker"); // modifies the copy only
Console.WriteLine("copy count=" + view.Count);
Console.WriteLine("original count=" + t.GetAllCopy().Count);
}
}
Suggerimenti sull'incapsulamento
Elenco di controllo:
- Campi privati; proprietà e metodi pubblici.
- Convalidi nei costruttori e nei setter.
- Mantenga veri gli invarianti dopo ogni chiamata.
- Non renda accessibili le raccolte interne.
Principio dell'incapsulamento
Riepilogo
Riepilogo: Incapsuli i dati con campi privati e API convalidate. Definisca un invariante e lo faccia rispettare nei costruttori, nei setter e nei metodi. Non renda mai accessibili le raccolte interne.
Domande Frequenti
La lezione «Incapsulamento e invarianti» è gratuita?
Sì — il testo completo di «Incapsulamento e invarianti» è 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 3 lezioni in totale.
Cosa imparerò in «Incapsulamento e invarianti»?
Nasconda lo stato interno, esponga operazioni sicure e mantenga valide le invarianti della classe (ad esempio saldo non negativo e intervalli validi). 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 3 di 3.
Quanto tempo richiede la lezione «Incapsulamento e invarianti»?
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
- Campi, proprietà automatiche e inizializzatori di oggetti
- Costruttori e membri statici
- Incapsulamento e invarianti