C# Methods : Part II

static void Main(string[] args)
{
int v;
TakeOut(out v);
Console.ReadLine();
}
static void TakeOut(out int x)
x = 5;
x *= 4;
Console.WriteLine("Now x equal to {0}",x);
}

Easy to understand, Right ?

The first line in the Main method declare the v variable but don't initialize it. The next line we call the method TakeOut with v as the parameter-value for the parameter x. Because we specify the out keyword we can initialize the variable inside the method and that exactly what we did. The first line in the TakeOut method initialize the parameter x to value of 5.

Important Note : Why TakeOut method assign the value to x and not to v ? Actually some of my students asked me this question 2 weeks ago. And my reply was "Tell me something, When we create TakeOut method did we know the name of the variable ? ". The parameter nothing more than a place-holder for something you need. You specify the type of that thing that you want. And here we specify a parameter of type int so any variable of type int can be a parameter-value for that parameter. So you must understand that you deal with x as a place-holder for any variable that will come in that place. When we call the method v will replace the x and the method will execute on that way. ok?

So let's go back to TakeOut method. After we assign a value to x we multiply it by 4 so x will be equal to 20. Any variable will go as a parameter-value for the parameter x will be equal to 20.

Method's Local variables existence

Before we talk about local variables we must discuss the next example of a console application.

static void Main(string[] args)
{
for(int x = 0; x <= 5;x++)
{
// I will do nothing here
}
Console.WriteLine(x);
}

If you compile this code you will get the following error " The name 'x' does not exist in the class or namespace 'forloop.Class1' ". Why ?

You must understand that variables are local to the building block that declares it and only that block can use these variables. These building blocks as you might know branching structure, looping structure and methods. Let's compile this example again with a little modification.

static void Main(string[] args)
{
for(int x = 0; x <= 5;x++)
{
Console.WriteLine(x);
}
}

Now this will work because inside the for block we ask the console to print the value of x.

Let's consider the same example with something new. (but I think a lot of you might know it)

class Class1
{
int x = 10;
static void Main(string[] args)
{
for(int x = 0; x <= 5;x++)
{
Console.WriteLine(x);
}
}
}

I think you may heard about classes in C# but just for now let's say that a class in another building block offered by C# and I will discuss it in my articles about OOP.

When you compile this code we will get the same result which we got it from the last example. So what's the difference ? actually I want let you know that if there is a local variable in a block of code (like x in the for loop) and there are a class variable with the same name the building block will use it's local variable and the global or class variable will be hidden while the program control executing the block's code.

If you understand the last 2 examples then you will understand the third one about methods. Let's check it.

Here we call method MethodTest from the Main method and if you compile this code you will get an error informing you that x does not exist in Class1 and I think now you know the reason Because x is local and valid only inside the code of MethodTest. Note that x is created in memory only when the program control reach the method and destroyed when the program control finish executing the method. So let's write the example to compile without any errors.

class Class1
{
static void Main(string[] args)
{
MethodTest();
Console.WriteLine(x);
}
static void MethodTest()
{
int x = 5;
Console.WriteLine(x);
}
}

Note: Method's parameters are local variables to the method and no other methods can use it. You must understand that automatic create-destroy of method's variables are very good for the memory because in our program there are variables which we will need it all the time (while the program is running) and there are variables which we don't need it all the time (like variable x here) so if x local to the method then C# compiler will create it when its execute MethodTest and destroy it when its finish MethodTest. Imagine that x is exists in memory all the program execution time. It will be a load on the memory and maybe with a huge number of variables in one program you will get " Out of memory" thing. But of course there are variables that exists all the execution type of the program and we will talk about it later when you talk about OOP. Another thing the automatic create-destroy local variables must be initialized by the programmer before we can use, Why ? ok think about it for a minute. The compiler needs to know the size of this variable to allocate the right memory amount.

Important Note : There's something called scoping and it's the concept of "Who can see my method, The class that the method created in or the other classes in my program ?" . And because I didn't discuss Objects and Classes yet I will not talk about it here but I will do in the next few articles about Classes and objects in C#.

Method Overloading

Method overloading is something pretty simple and easy. It's just a way to have more than one method having the same name but each method have a different signature but all methods with the same name and it's the most important thing here. Different signature means a different parameters order or different parameters data types or even another set of parameters for each method. So maybe we will have a method called Add that takes 2 integer parameters to add them and other one with the same name that takes 3 integer parameters and a third one which takes 4 double parameters. Let's explain it more by an example.

class Class1
{
static void Main(string[] args)
{
Add(5,6);
Add(5);
Add(5.2,5.8);
Console.ReadLine();
}
static int Add(int x, int y)
{
Console.WriteLine(x + y);
}
static void Add(int x)
{
Console.WriteLine(x + 1);
}
static void Add(double x, double y)
{
Console.WriteLine(x + y);
}
}

Pretty simple The first Add method here takes 2 integer parameters and add them and the second one with the same name takes only one integer parameter to add it to 1. The third one takes 2 double parameters. I think with .NET life is much better. Right ?

So in method overloading you can mix and match any set of parameters for more than one method with the same name and the C# compiler will choose the best method it will see for the parameters values when you want to execute the method. Something you must note here about implicit conversion and method overloading. I assume that you know about implicit conversion and because it needs a lot of pages to explain I prefer to explain it in a separate article. In implicit conversion C# converts the little size types to the bigger types if it needs too. For example we have a method Add which it takes 2 double parameters and if you specify 2 integer variables as a parameter values for the parameters C# will convert int to double because double is bigger than int and that's called a widening conversion. But if you overload the method with a version of int parameters the compiler will choose it.

I think I covered a lot of good information and concepts that you can use it. In my next articles I will begin introducing OOP with a hundreds of pages.

Thanks and good luck all.