Methods

As we write code to our software, it can get messy and complicated, to solve this issue, we break small parts of our software into methods.
A method is a block of instructions that are executed only when it's called, you can pass parameters to it and have it return a value.

Creating a method

A method has the follwing structure:

<access modifier> <instance or static> <return type> <method name>(<paramenters>)
{
}

Examples

This an exmaple of a method that can be accessed by everyone, indicated by the public access modifier.
Does not have a return, indicate by the void keyword.
Has a name of WriteToConsole.
And recieves one parameter, indicated by string message

public void WriteToConsole(string message)
{
  // code
}

For the method Add, it recieves to paramenters value1 and value2, both of type int, and returns the sum of both paramenters, indicated by the return keyword.

public int Add(int value1, int value2)
{
  return value1 + value2;
}

Breaking down these examples

Access Modifier

Access Modifier defines how the code can access part of your code. They are used not only for methods, but for classes, properties, enums, etc.

In C# there are four types of access modifiers:

Modifier	Description
private	The code can only be accessed inside the same class.
public	The code can be accessed for everyone.
internal	The code can only be accessed.
protected	The code can only be accessed inside the same class or classes that inherit from the declaring class.

You can also combine them, for example:

// Accessed public inside the project
public internal ...

// Accessed inly by classes that inherit an inside the same project
protected internal

Static vs Instance

A method that are not defined as static by the static keyword, is always an instance method.

Instance

To access an Instance method, first, you need to instantiate an object and it works with the instance data.

Let's use our calculator class as an example:

public class Calculator
{
  public int Add(int x, int y)
  {
    return x + y;
  }
}

public static Main()
{
  Calculator calc = new Calculator();

  int result = calc.Add(5,6);
}

Now, to exemplify what instance data are, let's modify our calculator class, our new calculator class, will have the properties X and Y, and a parameterless method.

public class Calculator
{
  public int X {get; set;}
  public int Y {get;set;}

  public int Add()
  {
    return X + Y;
  }
}

To use this:

static void Main()
{
  Calculator calc1 = new Calculator();
  calc1.X = 5;
  calc1.Y = 10;
  int result1 = calc1.Add();

  Calculator calc2 = new Calculator();
  calc2.X = 22;
  calc2.Y = 20;
  int result2 = calc2.Add();

  Console.WriteLine(result1); // Prints 15
  Console.WriteLine(result2); // Prints 42
}

Static

A static method is a unique to the application, meaning that everyone will use the same copy of the method. These methods lives in the Type level instead of a Instance level.

public class Calculator
{
  public static int Add(int x, int y)
  {
    return x + y;
  }
}

public static void Main()
{
  // calling a static method.
  int result = Calculator.Add(5,6);
}

An instance class can have multiple static/instance methods.
A static class can only have static methods and members.
A static method cannot be called from an instance of the object.

Return Types

A method can return a value to its caller, the type returned by the method are indicated before the method name, and they must have the return keyword. void methods does not return a value.

public void ExecuteAndDoesNotReturnAValue()
{
  // code
{

public string ExecuteAndReturnsAValue()
{
  return "This method has a return value";
}

Parameters and Arguments

Parameters are the options listed in the method signature. Arguments are the values passed to the method.

// The method signatures has parameters
// In this case, two paramenters, x and y
public int Add(int x, int y)
{
  return x + y;
}

public static Main()
{
  Calculator calc = new Calculator();

  // When calling the method, we pass **arguments** to its **paramenters**
  // in this scenario, we are passing 5 to x and 6 to y
  int result = calc.Add(5,6);
}

Polymorphism

Polymorphism is when the same method has multiple functionalities.

public class Calculator
{
  /// returns the sum of a and b
  public int Add(int a, int b)
  {
    return a + b;
  }

  // returns the sum of a, b and c
  public int Add(int a, int b, int c)
  {
    return a + b + c;
  }
}