C# Methods

static decimal AddVat(decimal price)
{
    return price * 1.2m;
}

static void PrintTitle(string text)
{
    Console.WriteLine(text.ToUpper());
}

decimal withVat = AddVat(50m);     // 60.0
PrintTitle("report");

• The return type comes first: decimal, string, bool, or void when nothing is returned.
• Parameters are listed in brackets with their types; the values you pass when calling are arguments.
• return sends a value back and ends the method immediately.
• Method names use PascalCase and usually start with a verb: CalculateTotal, SendEmail, IsValid.
• In top-level programs, methods written in Program.cs are local functions; inside classes they're members, often marked static when they don't use an object's data.

A method whose body is a single expression can use =>:

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

Optional parameters have a default value and can be left out:

static string Greet(string name, string greeting = "Hello") => $"{greeting}, {name}!";

Greet("Ada");                      // Hello, Ada!
Greet("Ada", "Welcome back");      // Welcome back, Ada!
Greet(greeting: "Hi", name: "Bo"); // named arguments, in any order

Named arguments make calls with several values readable: CreateUser("ada", isAdmin: true, sendEmail: false) is much clearer than CreateUser("ada", true, false).

Overloading means several methods share a name but take different parameters. C# picks the right one from the arguments:

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

To return more than one value, use a tuple:

static (int Min, int Max) Range(int[] values) => (values.Min(), values.Max());
var (low, high) = Range(new[] { 4, 9, 2 });

You'll also see out parameters, as in int.TryParse(text, out int n), which give back an extra value. ref lets a method change the caller's variable, and params int[] numbers accepts any number of arguments.

A method can call itself, which is called recursion. It suits problems that contain smaller copies of themselves, such as folders inside folders or menus inside menus. A classic example is the factorial, where 5! is 5 × 4 × 3 × 2 × 1:

static long Factorial(int n)
{
    if (n <= 1) return 1;          // base case: stop here
    return n * Factorial(n - 1);   // smaller version of the same problem
}

Console.WriteLine(Factorial(5));   // 120

Every recursive method needs a base case that returns without calling itself. Each call waits on the call stack until the call it made has finished, so a missing or unreachable base case keeps adding calls until the stack runs out. The result is a StackOverflowException, which ends the whole program and can't be caught with try/catch.

For simple counting jobs like this one, a loop is just as clear and uses less memory. Save recursion for tree-shaped data, where a loop would need you to manage your own stack of items.