Five Minute C# — Lesson 7

Parameters, arguments, and importing a module

Lessons: 1 ・ 2 ・ 3 ・ 4 ・ 5 ・ 6 ・ 7 ・ 8 ・ 9 ・ 10 ・ 11 ・ 12 ・ 13 ・ 14

Having an argument with myself

So we know how to make our own methods/functions. Look at you!

So let’s jump right into parameters. Here’s an example of a function making use of a parameter:

public void Apples(n)
{
  //something
}

Within the parentheses of the Apples() function is the value n. We can therefore call n a parameter of Apples().

But what good does that do? Well, later when we call Apples(), we will be able to input anything we want for a future value for n. Also, the nice thing about parameters is that you can have as many as you like for a function!

Next, arguments are what we call the values of the parameters, which we pass into the function. For example:

Apples(10);

The function Apples() was called with the parameter n set to the argument 10. Remember when you call a function, pass the same number of arguments as there are parameters.

You can even declare an object type as parameters.

public void Sum(int a, int b)
{
  //something
}

This is called parameter passing. Why do we need to use this? It can be useful when you want to return a value.

In lesson 6, we talked about functions returning values. In all of our examples, we voided the return type. This means, it will not return a value as it has been void. However, if we specify the return type, we will get a value according to what we told it to give us. For example…

public int Sum(int a, int b)
{
  int add = a + b;
  return add;
}

And then if we call the Sum(int a, int b) function and pass the arguments, let’s say 10 for a and 5 for b, and store the output into an integer called answer:

int answer = Sum(10, 5);

We can now display the answer:

Console.WriteLine(answer);

To which, we should get:

15

Great! That’s it for parameters and arguments (for now).

Now for something different… importing modules!

Remember how the C# compiler reads our script in terms of namespaces, classes, and functions? Sometimes we may need to add ‘plugins’ to our script. We do this by specifying exactly what we want to import at the very top of our script, ahead of everything else. By importing a module, we include a whole new set of definitions (including variables and functions) to play around with. A module is a file and forms part of a library.

For example, we want to include the System module. This will now give us access to the Math namespace.

using System;
namespace myProgram
{
  class myClass
  {
    void myFunction()
    {
      //do something
    }
  }
}

But this can be inefficient if all you want to do is just arithmetic, for example. Instead of importing the entire module, you can just say:

using static System.Math;
namespace myProgram
{
  class myClass
  {
    void myFunction()
    {
      //do something
    }
  }
}

Or, you could just not import a module at all and instead directly reference what you want to do.

namespace myProgram
{
  class myClass
  {
    void myFunction()
    {
      System.Math.Cos(x);
    }
  }
}

It’s nothing to do with it being faster or slower in loading libraries, so don’t worry. There’s no overhead in importing modules. It’s just a shortcut. However, if you do use the shortcut, you may encounter duplicate function names between say… Unity Math namespace and the Net Math namespace which could get confusing. One solution is to comment, and comment well!

For example:

y = Cos(x); //using Unity Cos
y = System.Math.Cos(x); //using .net Cos

I generally recommend importing modules because it saves time having to type the full namespace each time. But it is up to you.

Let’s use everything we know in this lesson to sum it up with one example. Let’s introduce 3 integer functions which contains 3 integer arguments in its parameter:

using System;
namespace Program
{
  class example
  {
    public int biggest(int arg1, int arg2, int arg3, int arg4)
    {
     Console.WriteLine(arg1, arg2, arg3, arg4);
     return Math.Max(arg1, arg2, arg3, arg4);
    }
    public int smallest(int arg1, int arg2, int arg3, int arg4)
    {
     Console.WriteLine(arg1, arg2, arg3, arg4);
     return Math.Min(arg1, arg2, arg3, arg4);
    }
    public int distFrom_zero(int arg)
    {
     Console.WriteLine(arg);
     return Math.Abs(arg);
    }
  }
}

Wow that looks so complicated! Take your time to go through each line and see what is going on. Don’t feel put off by it!

Now that you’ve read the snippet of code, let’s call those 3 functions and pass some arguments! Remember, since we specified what type of argument we want passed, in our case integers, we can only pass integers.

For biggest(int arg1, int arg2, int arg3, int arg4), I chose to pass 4,5,6,7. For smallest(int arg1, int arg2, int arg3, int arg4), I also chose to pass 4,5,6,7. Finally, for distFrom_zero(int arg), I passed -2. Here’s what we have so far on a separate function:

biggest(4,5,6,7);
smallest(4,5,6,7);
distFrom_zero(-2);

If we run the code, we should get the following result:

7
4
2

You may be thinking there must be better way to do this and you’re right! Instead of passing all those arguments, we can make use of arrays. We’ll talk more about this in our next lesson…

Well done for getting this far! This is how your code is written and read by the compiler.

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.