# Methods on a Class

Write instance methods that use and change an object's state safely, keep its rules inside the class, and know when a method should be static.

Apprentice · C# · OOP · Updated November 3, 2026

## After this lesson you can

- Write methods that use and change an object's state, keeping its rules inside the class

## Key takeaways

- Put each rule inside the class that owns the data, and give the data a `private set`, so only the class's methods can change it.
- A class's methods can call each other and use its properties without naming an object, as `Withdraw` calls `CanWithdraw`.
- An instance method reads or changes one object's state; a `static` method belongs to the class and needs only its parameters.
- `const` makes a value that never changes, such as `MaxPaper`, and constants are named in PascalCase.

Properties hold what an object knows; methods are what it does. A class's methods are where its rules live: what's allowed, what changes together, and what happens when something can't be done.

## A method that changes state, with rules

A printer has paper and toner. Printing uses one sheet and one unit of toner per copy, and it can't print more than it has. That rule belongs inside the `Printer` class, so no code anywhere can get it wrong:

```csharp
Printer printer = new Printer(paper: 10, toner: 100);

int printed = printer.Print(4);
Console.WriteLine($"Printed {printed}, {printer.Paper} sheets left");

printed = printer.Print(25);
Console.WriteLine($"Printed {printed}, {printer.Paper} sheets left");

printer.AddPaper(800);
Console.WriteLine($"After adding paper: {printer.Paper} sheets");

public class Printer
{
    public const int MaxPaper = 500;

    public int Paper { get; private set; }
    public int Toner { get; private set; }

    public Printer(int paper, int toner)
    {
        Paper = paper;
        Toner = toner;
    }

    // Prints as many copies as the paper and toner allow, and returns how many.
    public int Print(int copies)
    {
        if (copies <= 0)
        {
            return 0;
        }

        int possible = Math.Min(Paper, Toner);
        int printed = Math.Min(copies, possible);

        Paper -= printed;
        Toner -= printed;
        return printed;
    }

    public void AddPaper(int sheets)
    {
        Paper = Math.Min(Paper + sheets, MaxPaper);
    }
}
```

```text
Printed 4, 6 sheets left
Printed 6, 0 sheets left
After adding paper: 500 sheets
```

- `Paper` and `Toner` have `private set`, so the only way to change them is through `Print` and `AddPaper`, which follow the rules.
- `Math.Min` returns the smaller of two numbers.
- `const` makes `MaxPaper` a value that never changes. Constants are named in PascalCase.
- `new Printer(paper: 10, toner: 100)` names each argument. It's optional, but it makes calls with several numbers easy to read.

## Methods can use each other

Methods in a class can call each other, and use the class's properties, without naming an object: they work on the same object.

```csharp
BankAccount account = new BankAccount("Ana", 100m);
account.Withdraw(30m);
account.Withdraw(500m);
Console.WriteLine(account.Summary());

public class BankAccount
{
    public string Owner { get; }
    public decimal Balance { get; private set; }

    public BankAccount(string owner, decimal openingBalance)
    {
        Owner = owner;
        Balance = openingBalance;
    }

    public bool CanWithdraw(decimal amount) => amount > 0 && amount <= Balance;

    public bool Withdraw(decimal amount)
    {
        if (!CanWithdraw(amount))
        {
            return false;
        }
        Balance -= amount;
        return true;
    }

    public string Summary() => $"{Owner} has {Balance:C}";
}
```

```text
Ana has $70.00
```

`Withdraw` calls `CanWithdraw`, and the $500 withdrawal is refused because the balance would go below zero.

## Instance or static?

The methods in this lesson are **instance** methods: they belong to one object and use its state. `account.Withdraw(30m)` changes *that* account.

A `static` method, like the ones you wrote in the Methods chapter, belongs to the class itself and uses no object's state. You call it with the class's name: `Math.Min(3, 7)`. A good test: if a method needs to read or change an object's properties, it's an instance method. If it only needs its parameters, it can be static.

```csharp
Console.WriteLine(Temperature.ToCelsius(212));

public static class Temperature
{
    public static double ToCelsius(double fahrenheit) => (fahrenheit - 32) * 5 / 9;
}
```

```text
100
```

## Check yourself

2 questions to try on the lesson page.

## So what

An object's methods are its rules in action. Put each rule inside the class that owns the data, keep the data's `set` private, and every part of the program gets the rule right for free.

## Key terms

- [Instance Member](https://www.ask-codey.com/glossary/instance-member)
- [Static Member](https://www.ask-codey.com/glossary/static-member)
- [const](https://www.ask-codey.com/glossary/const)
- [Named Argument](https://www.ask-codey.com/glossary/named-argument)

## Cheat sheets

- [Methods on a Class](https://www.ask-codey.com/cheat-sheets/properties-in-csharp-methods-on-a-class-cheat-sheet)

Source: https://www.ask-codey.com/lessons/properties-in-csharp-methods-on-a-class