Methods and Functions in C# Explained: A Unity Dev's Guide

It's Monday... I know. But what better day to start the week with a blog post about the thing that saves you from writing the same chunk of code 50 times across your project: methods in C#. If you've ever copy-pasted a block of code into three different scripts and then had to fix a bug in all three places separately, this one's for you. We're going over what it is exactly, and the best way to implement methods when you're building your program.

Let's go!

What Exactly Is A Method?

A method is a named, reusable block of code that does one specific job. Write it once, call it as many times as you need, from wherever you need it. Instead of writing out the same five lines every time you want to deal damage to an enemy, you write TakeDamage() once and call that instead.

Think of a C# function like a vending machine. You put something in (optional), it does its thing internally, and it might hand something back out (also optional). You don't need to know exactly how it works inside, you just need to know what to give it and what you'll get back.

input (optional)  →  method runs its code  →  output (optional)

Writing Your First Method

Here's the simplest possible method, one that just prints a message with no input and no output:

private void SayHello()
{
    Debug.Log("Hello!");
}

Break that down piece by piece, since the syntax trips up a lot of beginners writing their first Unity method:

• void - the return type. void means this method doesn't hand anything back when it's done.
• SayHello - the method's name. Pick something that describes what it does.
• () - the parameter list. Empty here, meaning this method doesn't need any input to run.
• { } - the body. Whatever code sits inside these braces is what actually runs when the method is called.

To actually run it, you call it by name followed by parentheses, SayHello();, anywhere else in your script.

The Difference Between A Method And A Function

You probably wonder what the difference is between a method and a function. Well, they're both pretty much the same. If you insist to put some sort of label on it, a function is a general programming term for a reusable, named block of code that can take input and return output. It exists independently, not attached to anything.

A method is specifically a function that belongs to a class or object. In C#, since every single piece of callable code lives inside a class, there's no such thing as a free-floating function sitting outside a class like you'd find in C or Python. So technically, everything you write in C# is a method, never a "function" in the strict sense.

In practice, though, C# developers (and most tutorials, forums, and even Microsoft's own documentation at times) use "method" and "function" interchangeably anyway. You'll hear "write a function that calculates damage" just as often as "write a method that calculates damage," and everyone understands exactly what's meant.

Parameters: Giving a Method Information

Most useful methods need some input to work with. That's what parameters are for: values you hand the method when you call it.

private void TakeDamage(int amount)
{
    health -= amount;
    Debug.Log("Took " + amount + " damage. Health is now " + health);
}

Now calling TakeDamage(10) subtracts 10 from health, while TakeDamage(25) subtracts 25. Same method, different results, depending entirely on what you pass in. You can add more than one parameter too, just separate them with commas:

private void Attack(int damage, string weaponName)
{
    Debug.Log(weaponName + " deals " + damage + " damage.");
}

// called like this:
Attack(15, "Iron Sword");

If you're new to programming, and not quite sure how this works - don't worry. With repetition and putting it into practice you'll eventually get that 'aha moment'. When I first started out, it took me some time to wrap my head around this concept.

Return Types: Getting Information Back

Sometimes you don't just want a method to do something -- you want it to calculate something and hand the result back to you. That's where a return type comes in, replacing that void from earlier with an actual type.

private float CelsiusToFahrenheit(float celsius)
{
    return celsius * 9 / 5 + 32;
}

// called like this:
float result = CelsiusToFahrenheit(10);
Debug.Log(result); // 50

The return keyword is what actually hands the value back. The method's declared type, int in this case, has to match whatever type you're returning. Try to return a string from a method declared as int and the compiler will stop you immediately. This pattern, a C# function that calculates and returns a value, shows up constantly once you start building real game systems.

Parameters vs Arguments: A Quick Clarification

You'll hear these two words used almost interchangeably, but there's a subtle difference worth knowing:

• Parameter - the placeholder variable in the method's definition. In void TakeDamage(int amount), amount is the parameter.
• Argument - the actual value you pass in when calling it. In TakeDamage(10), 10 is the argument.

It's a small distinction, and honestly most devs use the words loosely in conversation, but it's worth knowing the difference exists.

Why Bother Writing a Method At All?

Beginners sometimes wonder why they shouldn't just write code inline wherever they need it. A few real reasons a Unity method earns its keep:

• Reusability - write the logic once, call it from a dozen places instead of pasting it a dozen times.
• Fixing bugs in one spot - found a bug in your damage calculation? Fix it once inside the method, every place that calls it is automatically fixed too.
• Readability - a well-named method like SpawnEnemyWave() tells you what's happening without reading every line inside it.
• Testing in isolation - it's much easier to verify one method works correctly than to untangle one giant block of inline code.

So Which Approach Should You Actually Use?

Here's the no-fluff version, the gut check you can run through in your head:

• Code you'll only ever run once, in one place → inline is fine
• Code you're about to copy-paste anywhere → stop, make it a method instead
• Need input to vary the behavior → add parameters
• Need a calculated value back → give it a return type instead of void
• Just performing an action with no result needed → void is the right call

Picking the right shape for a method in C# isn't about overthinking it, it's about asking "will I need this logic more than once, and do I need something back from it?" Answer those two questions and the structure writes itself.

Wrapping Up

Methods are one of those concepts that feel like extra typing at first, right up until your second script needs the exact same logic as your first one, and suddenly that one extra step of wrapping it in a method saves you from a maintenance headache down the line. Get comfortable writing methods with parameters and return types, and you've got one of the most fundamental building blocks of clean code fully in your hands. ~happy Coding!