Methods
Tags: csharp, beginners
Published: 2021-07-12 14:06:50

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:

```csharp
<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`
```csharp
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.
```csharp
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:

```csharp

// 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:

```csharp
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.

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

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

To use this:

```csharp
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.

```csharp
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.

```csharp
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.

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

```csharp
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.

```csharp
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;
  }
}
```

In the example the calculator class have two methods to add values, one that recieves 2 arguments, and another one that recieves 3 arguments.