DEV Community

loading...

Methods

Eduardo Julião
Software Developer | Geek since 1993 | @monsieurxuxu on twitter
・3 min read

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>)
{
}
Enter fullscreen mode Exit fullscreen mode

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
}
Enter fullscreen mode Exit fullscreen mode

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;
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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);
}
Enter fullscreen mode Exit fullscreen mode

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;
  }
}
Enter fullscreen mode Exit fullscreen mode

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
}
Enter fullscreen mode Exit fullscreen mode
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);
}
Enter fullscreen mode Exit fullscreen mode

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";
}
Enter fullscreen mode Exit fullscreen mode

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;
}
Enter fullscreen mode Exit fullscreen mode
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);
}
Enter fullscreen mode Exit fullscreen mode

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;
  }
}
Enter fullscreen mode Exit fullscreen mode

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

Discussion (0)