Writing methods

Why methods?

As programs grow, you'll notice the same few lines appearing again and again. A method gives a block of code a name, so you can run it whenever you need it by calling that name.

Methods make code:

• Reusable — write it once, call it anywhere.
• Readable — CalculateTax(price) says what happens; the details live inside the method.
• Testable — you can check a small method on its own. That's exactly how the exercises in this course are graded.

Anatomy of a method

int Add(int a, int b)
{
    return a + b;
}
//│  │    └──────── parameters: inputs, each with a type and name
//│  └───────────── the method's name (PascalCase)
//└──────────────── return type: the type of value it gives back

Calling it:

int sum = Add(2, 3);        // the arguments 2 and 3 become a and b
Console.WriteLine(sum);     // 5
Console.WriteLine(Add(10, Add(1, 1)));  // 12 — results can feed other calls

return hands a value back

return does two things: it gives a value back to the caller, and it exits the method immediately.

string Classify(int age)
{
    if (age < 13) return "child";
    if (age < 20) return "teenager";
    return "adult";
}

The return type is a promise: a method declared as int must return an int on every path, or the compiler complains.

void — methods that just do something

When a method performs an action and has nothing to give back, its return type is void:

void PrintBanner(string title)
{
    Console.WriteLine(new string('=', title.Length));
    Console.WriteLine(title);
    Console.WriteLine(new string('=', title.Length));
}
 
PrintBanner("Report");

Expression-bodied methods

When a method is a single expression, use => for a compact form:

int Square(int x) => x * x;
bool IsAdult(int age) => age >= 18;

It means exactly the same as { return x * x; }.

Optional and named arguments

Give a parameter a default value to make it optional:

string Greet(string name, string greeting = "Hello") => $"{greeting}, {name}!";
 
Greet("Ada");                          // "Hello, Ada!"
Greet("Ada", "Welcome");               // "Welcome, Ada!"
Greet(greeting: "Hey", name: "Ada");   // named arguments, any order

Optional parameters must come after the required ones.

Overloading

Several methods can share a name if their parameters differ:

int Max(int a, int b) => a > b ? a : b;
int Max(int a, int b, int c) => Max(Max(a, b), c);

The compiler picks the right one from the arguments you pass.

Where do methods live?

In a small program with top-level statements (like ours), you can declare methods right in the file — they're called local functions. In bigger programs, methods live inside classes, which you'll meet in the OOP track:

class Calculator
{
    public static int Add(int a, int b) => a + b;
}
 
Console.WriteLine(Calculator.Add(2, 3));

Try it

Change Classify so 65+ returns "senior", then run it:

Key takeaways

• A method = return type + name + parameters + body.
• return gives a value back and exits; void methods return nothing.
• Prefer returning values over printing them inside the method.
• => for one-liners, default values for optional parameters, overloads for variations.