Object-Oriented Programming di C#, Dasarnya

Object-Oriented Programming pada dasarnya memodelkan kode sebagai object yang berinteraksi daripada urutan prosedur. C# menerapkan konsep ini melalui 4 pilar utama, ditambah dengan mekansime pendukung language.

Empat Pillar

Encapsulation

Untuk apa? Untuk menyembunyikan state internal dan memaksa interaksi melalui interface yang terkontrol supaya representasi internal bisa diubah tanpa merusak pemanggil-pemanggil.

Tanpa Encapsulation (Caller bisa “break”)

public class BankAccount
{
    public double Balance; // field public, akses langsung
}

// Caller
var account = new BankAccount();
account.Balance = 1000;
Console.WriteLine(account.Balance);

Apabila type Balance diubah, seluruh pemanggilnya akan rusak

Dengan Encapsulation (Caller aman)

public class BankAccount
{
    private double _balance; // disembunyikan

    public double Balance => _balance; // exposed lewat property

    public void Deposit(double amount)
    {
        if (amount <= 0)
            throw new ArgumentException("Amount must be positive");
        
        _balance += amount;
    }

    public void Withdraw(double amount)
    {
        if (amount > _balance)
            throw new InvalidOperationException("Insufficient funds");

        _balance -= amount;
    }
}

// Caller
var account = new BankAccount();
account.Deposit(1000);
account.Withdraw(200);
Console.WriteLine(account.Balance);

Sekarang, kalau internal representasinya diubah, misalnya:

public class BankAccount
{
    private Money _balance; // ganti dari double ke Money

    public double Balance => _balance.ToDouble(); // interface publik tetap sama

    public void Deposit(double amount)
    {
        _balance = _balance.Add(new Money(amount));
    }
    // ...
}

Penerapan dengan Property

1. Menambahkan validasi/logic tanpa mengubah cara caller

public class Person
{
    private int _age;

    public int Age
    {
        get => _age;
        set
        {
            if (value < 0)
                throw new ArgumentException("Age tidak boleh negatif");
            _age = value;
        }
    }
}

// Caller tetap sama persis:
person.Age = 25; // terlihat seperti akses field biasa, padahal ada validasi di baliknya

2. Kontrol akses read/write secara terpisah

public string Name { get; private set; } // caller cuma bisa baca, tidak bisa ubah dari luar

3. Bisa ubah implementasi internal tanpa break caller (ini poin utama encapsulation)

Auto-property sederhana:

public double Balance { get; set; }

Lalu berkembang jadi computed property tanpa mengubah cara caller memanggilnya:

private double _principal;
private double _interestRate;

public double Balance => _principal * (1 + _interestRate); // dihitung, bukan disimpan langsung