Access modifiers, static members and encapsulation

Encapsulation: protect the data

Encapsulation is one of the main ideas of OOP. An object hides its data and exposes only the actions that keep it valid. A bank account should never have a negative balance by accident, so the balance is private and the only way to change it is Deposit or Withdraw, which check the rules.

Access modifiers

An assembly is the .dll your project builds. internal is useful for helper classes that other projects should not depend on.

public class BankAccount
{
    private decimal _balance;                 // hidden
    public string Owner { get; }
    public decimal Balance => _balance;       // read-only view

    public BankAccount(string owner) => Owner = owner;

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

    public bool TryWithdraw(decimal amount)
    {
        if (amount <= 0 || amount > _balance) return false;
        _balance -= amount;
        return true;
    }
}

static members: shared by the whole class

Normally each object has its own fields. A static field belongs to the class itself, so there is only one copy, shared by all objects. A static method belongs to the class too, so you call it on the class name, without creating an object. Math.Max and Console.WriteLine are static methods.

var t1 = new Ticket("Asha");
var t2 = new Ticket("Ravi");
Console.WriteLine($"{t1.No} {t2.No}");         // 1001 1002
Console.WriteLine(Ticket.IssuedSoFar);         // 2

class Ticket
{
    private static int _nextNo = 1001;     // one counter for all tickets
    public int No { get; }
    public string Passenger { get; }

    public Ticket(string passenger)
    {
        Passenger = passenger;
        No = _nextNo++;                     // use, then increase
    }

    public static int IssuedSoFar => _nextNo - 1001;
}

static classes

Console.WriteLine(Gst.Add(1000m));   // 1180.00

public static class Gst
{
    public const decimal StandardRate = 0.18m;
    public static decimal Add(decimal amount, decimal rate = StandardRate) => amount + amount * rate;
}

const, readonly and static readonly

Common mistakes and fixes

• Making everything public "to make it work": you lose the protection. Start with private and open up only what callers truly need.
• Forgetting that members are private by default: void Deposit() inside a class cannot be called from outside. Add public.
• Using a static field for per-user data like the "current user": every object and every request shares it. Use an instance field instead.
• Trying to new a static class: error. Call its members on the class name.