Methods

A method is a named block of code that takes some inputs (parameters), does one job and optionally hands back a result (its return value). The first line of a method, its signature, says all of that: static int Square(int n) reads "a method called Square that takes an int called n and returns an int". A method that returns nothing is declared void.

In a file-based C# program you can write a method in two places. Among the top-level statements, it is a local function: it belongs to the hidden Main and can be called from anywhere in the top-level code, even above where it is written. Inside a class, it is a normal method; mark it static when it does not need an object, and call it as ClassName.Method(). Real projects put almost every method on a type; small scripts and this handbook use both.

Greet("Ana");
Console.WriteLine(Square(7));
Console.WriteLine(MathUtil.Cube(3));
Console.WriteLine(MathUtil.IsEven(10));

// local functions: callable anywhere in the top-level code
static void Greet(string name)
{
    Console.WriteLine($"Hello, {name}!");
}

static int Square(int n)
{
    return n * n;
}

// a static method on a class: called as MathUtil.Cube(...)
static class MathUtil
{
    public static int Cube(int n) => n * n * n;

    public static bool IsEven(int n) => n % 2 == 0;
}

Hello, Ana!
49
27
True

The return statement ends the method immediately and hands the value back. A method declared to return int must return an int on every path through it; the compiler checks this, and a missing return after an if is one of the first errors every beginner meets.

Console.WriteLine(Sign(-4));

static string Sign(int n)
{
    if (n > 0) return "positive";
    if (n < 0) return "negative";
}

Program.cs(3,15): error CS0161: 'Sign(int)': not all code paths return a value

Console.WriteLine(Sign(-4));

static string Sign(int n)
{
    if (n > 0) return "positive";
    if (n < 0) return "negative";
    return "zero";
}

A parameter is the variable in the method declaration; an argument is the value you pass at the call. By default arguments are matched to parameters by position. Two features make calls more readable: an optional parameter has a default value (int tries = 3) so the caller can leave it out, and a named argument (tries: 5) says which parameter a value is for, so the call reads like a sentence and you can skip optional ones in the middle.

Console.WriteLine(FormatPrice(1234.56));
Console.WriteLine(FormatPrice(1234.56, "EUR"));
Console.WriteLine(FormatPrice(1234.56, decimals: 0));
Console.WriteLine(FormatPrice(currency: "GBP", amount: 9.99));

static string FormatPrice(double amount, string currency = "USD", int decimals = 2)
{
    string number = amount.ToString("N" + decimals, System.Globalization.CultureInfo.InvariantCulture);
    return $"{number} {currency}";
}

1,234.56 USD
1,234.56 EUR
1,235 USD
9.99 GBP

• Optional parameters must come after all required ones.
• A default value must be a compile-time constant (3, "USD", null, default), not DateTime.Now or new List<int>().
• Once you pass a named argument out of position, every argument after it must be named too.
• Named arguments pay off most for bool parameters: Save(overwrite: true) says what Save(true) hides.

Console.WriteLine(Area(5));

static double Area(double width, double height) => width * height;

Program.cs(1,19): error CS7036: There is no argument given that corresponds to the required parameter 'height' of 'Area(double, double)'

Console.WriteLine(Area(5, 2));
Console.WriteLine(Area(5));

static double Area(double width, double height = 1) => width * height;

params lets a method take any number of arguments of one type. The caller writes Sum(1, 2, 3) and the method receives them as a single collection; the caller can also pass an existing array. It must be the last parameter. Since C# 13 the params parameter may be a ReadOnlySpan<T> or a List<T> as well as an array; params T[] is still what you will read in most code.

Console.WriteLine(Sum());
Console.WriteLine(Sum(4));
Console.WriteLine(Sum(1, 2, 3, 4));

int[] saved = { 10, 20 };
Console.WriteLine(Sum(saved));

Console.WriteLine(Join("-", "a", "b", "c"));

static int Sum(params int[] numbers)
{
    int total = 0;
    foreach (int n in numbers) total += n;
    return total;
}

static string Join(string separator, params string[] parts) =>
    string.Join(separator, parts);

0
4
10
30
a-b-c

Overloading means several methods share one name but have different parameter lists: a different number of parameters, or different types. The compiler picks the best match at compile time from the arguments. The return type is not part of the choice, so two methods that differ only in what they return cannot coexist. Console.WriteLine itself has 18 overloads, which is why it accepts an int, a string or a bool.

Console.WriteLine(Describe.Of(42));
Console.WriteLine(Describe.Of(4.2));
Console.WriteLine(Describe.Of("42"));
Console.WriteLine(Describe.Of(4, 2));
Console.WriteLine(Describe.Of('x'));   // char widens to int

static class Describe
{
    public static string Of(int n) => $"int {n}";
    public static string Of(double d) => $"double {d}";
    public static string Of(string s) => $"string \"{s}\"";
    public static string Of(int a, int b) => $"two ints {a},{b}";
}

int 42
double 4.2
string "42"
two ints 4,2
int 120

Console.WriteLine(Pick.Max(1, 2));

static class Pick
{
    public static double Max(int a, double b) => Math.Max(a, b);
    public static double Max(double a, int b) => Math.Max(a, b);
}

Program.cs(1,24): error CS0121: The call is ambiguous between the following methods or properties: 'Pick.Max(int, double)' and 'Pick.Max(double, int)'

Console.WriteLine(Pick.Max(1, 2));

static class Pick
{
    public static double Max(double a, double b) => Math.Max(a, b);
}

By default C# passes every argument by value: the parameter is a new variable holding a copy of what the caller passed. What that copy is depends on the type. For a value type (int, double, bool, any struct) the copy is the data itself, so the method cannot touch the caller's variable. For a reference type (arrays, List<T>, string, any class) the copy is a reference to the same object on the heap, so the method can change the object, but pointing its own parameter at a new object does nothing to the caller.

int score = 10;
AddBonus(score);
Console.WriteLine($"score after AddBonus: {score}");

int[] scores = { 10, 20 };
AddBonusToAll(scores);
Console.WriteLine($"scores after AddBonusToAll: {string.Join(", ", scores)}");

Replace(scores);
Console.WriteLine($"scores after Replace: {string.Join(", ", scores)}");

static void AddBonus(int s)
{
    s += 5;                      // changes the local copy only
}

static void AddBonusToAll(int[] arr)
{
    for (int i = 0; i < arr.Length; i++) arr[i] += 5;   // same array object
}

static void Replace(int[] arr)
{
    arr = new[] { 0, 0 };        // re-points the local copy of the reference
    arr[0] = 99;
}

score after AddBonus: 10
scores after AddBonusToAll: 15, 25
scores after Replace: 15, 25

The rule in one line: a method can mutate an object you pass it, but cannot reassign your variable, unless the parameter is declared ref or out. The next lesson covers those.

Three modifiers pass an argument by reference: the parameter becomes another name for the caller's variable, not a copy of it. The modifier is written at both the declaration and the call, so a reader of the call can see that the variable may change.

When a method is a single expression, the => form drops the braces and the return: static int Square(int n) => n * n; means exactly the same as the block version. It works for methods, properties, constructors and operators. Use it when the whole body fits comfortably on one line; switch back to braces the moment you need a second statement.

A recursive method calls itself on a smaller version of the problem. Every recursive method needs a base case that answers directly without recursing, and every recursive call must move towards it. Each call gets its own frame on the call stack with its own parameters, which is what the trace below shows.

Console.WriteLine(Power(2, 10));
Console.WriteLine(SumDigits(9045));
Console.WriteLine(Countdown(3));

static long Power(long b, int exp) => exp == 0 ? 1 : b * Power(b, exp - 1);

static int SumDigits(int n) => n < 10 ? n : n % 10 + SumDigits(n / 10);

static string Countdown(int n) => n == 0 ? "liftoff" : n + " " + Countdown(n - 1);

1024
18
3 2 1 liftoff

A method has one return type, but that type can be a tuple: (int Min, int Max) is a lightweight value holding two named ints. The caller can keep the tuple and read result.Min, or deconstruct it straight into separate variables with var (lo, hi) = MinMax(data);. Use a discard _ for a part you do not need.

int[] temps = { 18, 25, 11, 30, 22 };

var stats = MinMax(temps);
Console.WriteLine($"min {stats.Min}, max {stats.Max}");

var (lo, hi) = MinMax(temps);          // deconstruction
Console.WriteLine($"range {hi - lo}");

var (_, top) = MinMax(temps);          // discard the min
Console.WriteLine($"top {top}");

var (q, r) = DivRem(17, 5);
Console.WriteLine($"17 = 5 * {q} + {r}");

(lo, hi) = (hi, lo);                    // swap without a temp variable
Console.WriteLine($"lo={lo} hi={hi}");

static (int Min, int Max) MinMax(int[] values)
{
    int min = values[0], max = values[0];
    foreach (int v in values)
    {
        if (v < min) min = v;
        if (v > max) max = v;
    }
    return (min, max);
}

static (int Quotient, int Remainder) DivRem(int a, int b) => (a / b, a % b);

min 11, max 30
range 19
top 30
17 = 5 * 3 + 2
lo=30 hi=11

A local function is a method declared inside another method. It is visible only there, which keeps a helper next to the one place that uses it instead of cluttering the class. A local function can read and change the enclosing method's variables (it captures them). Mark it static to forbid capturing: the compiler then guarantees it depends only on its parameters, which makes it easier to read and cheaper to call.

Console.WriteLine(Report.Build(new[] { 3, -1, 8, 0, -5 }));

static class Report
{
    public static string Build(int[] values)
    {
        int skipped = 0;
        var kept = new List<string>();

        foreach (int v in values)
        {
            if (IsUsable(v)) kept.Add(Label(v));
            else Skip();
        }
        return $"{string.Join(" ", kept)} (skipped {skipped})";

        // captures 'skipped' from Build
        void Skip() => skipped++;

        // static: uses only its parameter
        static bool IsUsable(int n) => n > 0;
        static string Label(int n) => $"[{n}]";
    }
}

[3] [8] (skipped 3)

int limit = 10;
Console.WriteLine(IsSmall(4));

static bool IsSmall(int n) => n < limit;

Program.cs(4,35): error CS8421: A static local function cannot contain a reference to 'limit'.

int limit = 10;
Console.WriteLine(IsSmall(4, limit));

static bool IsSmall(int n, int max) => n < max;

Signature

A method's name plus its parameter types (and ref/out/in modifiers). Overloads must differ in signature; the return type does not count.

Parameter / argument

The parameter is the variable in the declaration; the argument is the value passed at the call.

Optional parameter

A parameter with a compile-time constant default, so callers may leave it out.

Named argument

An argument written as name: value, matched by name instead of position.

params

Marks the last parameter as taking any number of arguments, received as one array or collection.

Overloading

Several methods on one type with the same name and different parameter lists; the compiler picks one at compile time.

ref / out / in

Pass the caller's variable itself: ref = read and write, out = must be assigned by the method, in = read-only.

Expression-bodied member

A member whose body is a single expression after =>.

Base case

The input a recursive method answers directly, without calling itself; it is what stops the recursion.

Deconstruction

Unpacking a tuple or record into separate variables: var (a, b) = pair;.

Local function

A method declared inside another method; static local functions cannot capture outer variables.

var list = new List<int> { 1 };
Change(list);
Console.WriteLine(list.Count);

static void Change(List<int> l)
{
    l.Add(2);
    l = new List<int>();
    l.Add(3);
}