📝 Lesson 3.3: Methods

What Is a Method?

A method is a named block of code that performs a specific task. You've been using methods all along — Console.WriteLine is a method, and so is int.Parse. Now you'll write your own.

Think of a method like a recipe. The recipe is written down once (the definition). Whenever you want the dish, you "follow the recipe" (call the method). You can even hand it inputs — ingredients (parameters) — and get a result back — the finished dish (return value).

Defining and Calling

The simplest method takes no input and returns nothing — it just does a task. The keyword void means "returns nothing":

// Define the method
void Greet()
{
    Console.WriteLine("Hello there!");
    Console.WriteLine("Welcome to the program.");
}

// Call it (as many times as you like)
Greet();
Greet();

Hello there!
Welcome to the program.
Hello there!
Welcome to the program.

The anatomy of that definition:

• void — the return type; void means it gives nothing back.
• Greet — the method name. By convention, method names use PascalCase (each word capitalized).
• () — the parameter list, empty here (no inputs).
• { ... } — the body: the code that runs when you call it.

Parameters: Passing Data In

Methods become far more useful when you can feed them different data. Parameters are variables listed in the parentheses that receive the values you pass in (those values are called arguments):

// 'name' is a parameter
void Greet(string name)
{
    Console.WriteLine($"Hello, {name}!");
}

Greet("Ada");     // "Ada" is the argument
Greet("Grace");
Greet("Alan");

Hello, Ada!
Hello, Grace!
Hello, Alan!

One definition, three different results — that's the power of parameters. You can have several, separated by commas:

void Describe(string name, int age)
{
    Console.WriteLine($"{name} is {age} years old.");
}

Describe("Ada", 30);
Describe("Grace", 45);

Return Values: Getting Data Out

Often you want a method to compute something and hand the result back so you can use it. Instead of void, declare the type of value the method returns, and use the return keyword to send it back:

// Returns an int
int Add(int a, int b)
{
    return a + b;
}

int sum = Add(3, 4);              // sum is now 7
Console.WriteLine(sum);          // 7
Console.WriteLine(Add(10, 20));  // 30 — use the result directly

Here int Add(...) promises to return an int. The return a + b; line computes the value and immediately sends it back to whoever called the method. The call Add(3, 4) is then replaced by its result, 7 — just like an expression.

A method that returns a bool reads beautifully in an if:

bool IsEven(int number)
{
    return number % 2 == 0;
}

if (IsEven(10))
{
    Console.WriteLine("10 is even");   // this runs
}

Variable Scope

Scope is the region of code where a variable exists and can be used. A variable declared inside a method (including its parameters) is local to that method — it doesn't exist outside it:

int Square(int n)
{
    int result = n * n;   // 'result' lives only inside Square
    return result;
}

Console.WriteLine(Square(5));   // 25
// Console.WriteLine(result);   // ❌ Error — 'result' doesn't exist out here

💡 The rule of thumb: A variable exists only within the braces { } where it was declared. Once you leave that block, the variable is gone. The clean way to move data out of a method is to return it.

Why Methods Matter (DRY)

Methods aren't just tidy — they solve real problems that grow with your program:

• Reuse: Write logic once, call it everywhere. Fixing a bug means fixing it in one place.
• Readability: A well-named method call like CalculateTax(price) reads like a sentence and hides the messy details.
• Testability: Small, focused methods are easy to reason about and check.

Compare these two approaches to greeting three people:

// Repetitive — the same pattern copied three times
Console.WriteLine("Hello, Ada! Welcome aboard.");
Console.WriteLine("Hello, Grace! Welcome aboard.");
Console.WriteLine("Hello, Alan! Welcome aboard.");

// DRY — one method, called three times
void Welcome(string name)
{
    Console.WriteLine($"Hello, {name}! Welcome aboard.");
}
Welcome("Ada");
Welcome("Grace");
Welcome("Alan");

If the greeting wording ever changes, the DRY version needs just one edit — inside the method.

Exercise & Quiz

// TODO: define Multiply, IsPositive, PrintBanner

// Example calls (uncomment once your methods exist):
// PrintBanner("Method Toolbox");
// Console.WriteLine($"3 x 4 = {Multiply(3, 4)}");
// Console.WriteLine($"Is -5 positive? {IsPositive(-5)}");

PrintBanner("Method Toolbox");
Console.WriteLine($"3 x 4 = {Multiply(3, 4)}");
Console.WriteLine($"Is -5 positive? {IsPositive(-5)}");
Console.WriteLine($"Is 8 positive? {IsPositive(8)}");

int Multiply(int a, int b)
{
    return a * b;
}

bool IsPositive(int n)
{
    return n > 0;
}

void PrintBanner(string text)
{
    Console.WriteLine("--------------------");
    Console.WriteLine(text);
    Console.WriteLine("--------------------");
}

--------------------
Method Toolbox
--------------------
3 x 4 = 12
Is -5 positive? False
Is 8 positive? True

Summary

📚 Additional Resources

• Methods — C# Programming Guide
• Methods overview — Microsoft Docs

🚀 What's Next?

That completes Module 3 — you can now branch, loop, and organize code into methods! In Module 4, we start working with more data at once. First up: Lesson 4.1: Collections — Arrays and Lists, which pairs perfectly with the loops and methods you just learned.