Look Under the Hood of C# Program Execution: Part 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
namespace Test1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Sourav Kayal");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
namespace Test1
{
    class Program
    {
        static void Main(string[] args)
        {
            string name = "Sourav Kayal";
            Console.WriteLine(name);
        }
    }
}

• IL_0000: ldstr : Load String constant onto stack

• IL_0005:stloc.0 : Store data (here a string) in local-0 variable from top of stack.

• IL_0006:ldloc.0 : Load data onto the stack from local variable-0

• IL_0007:call : Call to WriteLine() static function.

• IL_000c:ret : Return from the program.

In this program we are also seeing at first the string constant is created on the stack and then it's loaded to a local variable. And when we are using this local variable in our WriteLine() function as a argument at first the value of local variable is being loaded onto the stack and then it's passed as an argument. Here we can clearly see again "Before calling a function it is necessary to push the argument onto the stack".

Sourav, stop working with Strings and show something else.

Then let me show an example with an integer value. Here is my code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
namespace Test1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 100;
            Console.WriteLine(a);
        }
    }
}

In this program we are creating one integer variable and initializing it with the value 100 and passing it as an argument of the WriteLine() function. The following is the IL code window. Here we will see a very similar output with the String allocation process not much different.

• IL_0000 : ldc.i4.s : Load numeric constant onto stack

• IL_0002 : stloc.0 : Store value to local variable from top of the stack.

• IL_0003 :ldloc.0 : Load local variable data onto stack. (See, again the value is being loaded onto the stack.)

• IL_0004 :call : Call to the static function with an argument from the top of the stack.

Let's see how the addition operation is performed on the stack.

Here is the very simple program for the addition operation. Let's see the line-by-line execution.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
namespace Test1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 100;
            int b = 100;
            Console.WriteLine(a+b);
        }
    }
}

The output IL code window is here.

• IL_0000: ldc.i4.s : Load integer constant onto stack (first variable).

• IL_0002:stloc.0 : Move the top of the stack to a local variable. (0 indicating first variable.)

• IL_0003:ldc.i4.s : Load an integer constant onto the stack (second variable).

• IL_0005:stloc.1 : Move top of stack to local variable(1 indicating second variable).

• IL_0006:ldloc.0 : Load local variable 0 (first variable) on stack.

• IL_0007.ldloc.1 : Load local variable 1 (second variable) on stack.

• IL_0008:add : Perform add operation. (See, the Add operation is performed with the stack value, top two values.)

Note: Before any arithmetic operation the necessary values need to be loaded onto the stack. You may try with subtraction or division.

We return value the happily, but where is the value returned?

Why? The value is returned to the caller function?

Very frequently we write a return statement to return something from a function and when we began learning programming our teacher taught us that when we return something from a function it is returned to the caller function. (My teacher also told me that.) But here we will see what happens exactly, when we return some value from a function.

Here is my simple code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
namespace Test1
{
    class Program
    {
        static Int32 Call()
        {
            return 100;
        }
        static void Main(string[] args)
        {
            Call();
        }
    }
}

In the right side my main function IL code is shown and the left window contains the body of the Call function. This call function returns the value (100) to the Main function but if we closely look at the IL code of the Call() function then we will see the value is created on the top of the stack (ldc.i4.s) then the control is being returned from the Call function and along with the return statement is the attached value.

Note: the Return statement does not return anything, just keeps the latest value on the stack.

Conclusion

Here I have tried to represent a few first days of programming concepts in my own style. If we really like it (or even dislike it) then please leave your valuable comment in the following. Don't forget "Your single comment is enough to reduce my sleep time in half due to preparation of a more interesting document in part 2".