Encapsulación e invariantes
Oculte el estado interno, exponga operaciones seguras y mantenga verdaderas las invariantes de la clase (por ejemplo, saldo no negativo y rangos válidos).
Encapsulación e invariantes es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 3. 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 3 lecciones en total.
Descripción general de la encapsulación
Objetivo: proteger el estado de su objeto.
- Encapsulación: oculte los campos y exponga API seguras
- Invariante: una regla que siempre se cumple
- Valide en constructores, establecedores y métodos
Interfaz de solo lectura
Mantenga los campos private. Proporcione a los llamadores una propiedad de solo lectura y operaciones seguras.
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);
}
}
Validaciones en constructores
Los constructores establecen el estado obligatorio. Rechace las entradas no válidas para que los objetos sean válidos desde el principio.
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);
}
}
}
La invariante en la práctica
Defina una invariante (por ejemplo, Balance ≥ 0) y hágala cumplir en los establecedores y métodos.
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);
}
}
Protección de colecciones
No exponga directamente las listas o matrices internas. Devuelva una copia (o una vista de solo lectura) para proteger las invariantes.
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);
}
}
Consejos sobre encapsulación
Lista de comprobación:
- Campos privados; propiedades y métodos públicos.
- Valide en el constructor y en los establecedores.
- Mantenga las invariantes después de cada llamada.
- No exponga las colecciones internas.
Principio de encapsulación
Repaso
Repaso: encapsule con campos privados y API validadas. Defina una invariante y hágala cumplir en constructores, establecedores y métodos. No exponga nunca las colecciones internas.
Preguntas frecuentes
¿La lección «Encapsulación e invariantes» es gratis?
Sí — el texto completo de «Encapsulación e invariantes» 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 3 lecciones en total.
¿Qué aprenderé en «Encapsulación e invariantes»?
Oculte el estado interno, exponga operaciones seguras y mantenga verdaderas las invariantes de la clase (por ejemplo, saldo no negativo y rangos válidos). 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 3.
¿Cuánto tiempo toma la lección «Encapsulación e invariantes»?
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
- Campos, propiedades automáticas e inicializadores de objetos
- Constructores y miembros estáticos
- Encapsulación e invariantes