How does C# code get compiled and executed?

When you write C# code and execute the program within the .NET framework, how does the computer interpret the plain text code and produce the desired output?? In this article, we are going to learn about this whole process.

Compiler vs Interpreter

First, I have a question for you. Can computers know our language? We all write code with characters, numbers, etc. that we understand. But do computers know it like us? The answer is … NO! Computers can only understand the 0 and 1 language and return results based on them. So if we want to tell computers to do something, we have to use 0 and 1 to order them. However, it is too difficult for us to write some “meaningless” numbers, our languages are based on characters, not numbers. So how can we deal with the problems?

The answer is that we have to translate our known languages into machine code, so computers can fully understand what they are told to do. Now in the computer science world, there are commonly 2 ways to do this:

1. Compiler
2. Interpreter

What is a Compiler?

The Compiler is a translator that takes input i.e., High-Level Language, and produces an output of low-level language i.e. machine or assembly language. The work of a Compiler is to transform the codes written in the programming language into machine code (format of 0s and 1s) so that computers can understand.

• A compiler is more intelligent than an assembler it checks all kinds of limits, ranges, errors, etc.
• But its program run time is longer and occupies a larger part of memory. It has a slow speed because a compiler goes through the entire program and then translates the entire program into machine codes.
• Examples of compiled languages include C, C++, and Rust.

Role of a Compiler

For Converting the code written in a high-level language into machine-level language so that computers can easily understand, we use a compiler. Converts basically convert high-level language to intermediate assembly language by a compiler and then assembled into machine code by an assembler.

Advantages of Compiler

• Since the code is translated into machine code all at once, compiled programs generally run faster in comparison to Interpreted code.
• Compilers help improve the security of applications because Once compiled, the executable can be distributed without requiring the source code.
• Compilers give Debugging tools, which help in fixing errors easily.

Disadvantages of Compiler

• The compiler can catch only syntax errors and some semantic errors.
• Compilation can take more time in the case of bulky code.
• Compiled code is often platform-specific (unless cross-compilation is used), meaning a program compiled for one operating system may not run on another without recompiling.
• Any changes in the source code require the program to be recompiled, which can be cumbersome for iterative development.

What is an Interpreter?

An Interpreter is a program that translates a programming language into a comprehensible language. The interpreter converts high-level language to an intermediate language. It contains pre-compiled code, source code, etc.

• It translates only one statement of the program at a time.
• Interpreters, more often than not are smaller than compilers.?
• Examples of interpreted languages include Python, Ruby, and JavaScript.

Role of an Interpreter

The simple role of an interpreter is to translate the material into a target language. An Interpreter works line by line on a code. It also converts high-level language to machine language.

Advantages of Interpreter

• Since code is executed line by line, there is no need to compile the entire program, making it easier and faster to test and debug small changes.
• Interpreters allow the management of memory automatically, which reduces memory error risks.
• Interpreted languages often run on multiple platforms without requiring modifications, as long as the interpreter is available on those platforms.

Disadvantages of Interpreter

• The interpreter can run only the corresponding Interpreted program.
• Because the interpreter translates code at runtime, interpreted programs tend to run slower compared to compiled programs.
• Since the interpreter needs to keep track of the execution state, interpreted programs can consume more memory.
• Errors in the code might only appear when the interpreter encounters the specific line during execution, potentially leading to less efficient error detection.

However, There is another way to execute code, but we’ll learn about this in the next section.

C# and How does it work?

So what is C#? For those who do not know yet, C# is a modern, object-oriented programming language created by Microsoft as a component of the .NET framework. And .NET is a development platform that offers various tools and libraries for creating applications compatible with Windows, macOS, and Linux. Known for its simplicity, robustness, and type safety, C# is commonly used to develop desktop applications, web applications, and games.

When we think about C#, people just think that is the next-gen of C++ (like C++ is the next-gen of C ). However, Unlike C++, C# does not compile code directly into Machine Language using a compiler. Instead, it uses Just-In-Time Compiler a.k.a JIT.

What is JIT?

JIT is a hybrid approach that combines aspects of both compilers and interpreters. It translates code into machine code at runtime, rather than before execution (like a traditional compiler) or interpreting line-by-line (like an interpreter).

Step-by-step process of C# code compilation

Step 1: Write a C# code.

Step 2: Compile the code using a C# compiler.

Step 3: Now compiler checks if the code contains an error or not. If no error is found then the compiler moves to the next step. Or if the compiler finds errors, then it will immediately tell the developer that an error is found in the given line, so that the developer can correct them. After correcting the error when you again run the code the compiler again checks for the errors, if no error is found then it will move to the next step or if an error is found then the compiler gives a message to the developer. In C# there are two types of errors:

Compiler error: Errors that occur when the developer violates the rules of writing syntax are known as Compile-Time errors. This compiler error indicates something that must be fixed before the code can be compiled. All these errors are generally detected by the compiler and thus are known as compile-time errors. For example, missing semicolon, missing parenthesis, etc.

Runtime error: Errors that occur during program execution(run-time) after successful compilation are called run-time errors. One of the most common run-time errors is division by zero also known as Division error. These types of errors are hard to find as the compiler doesn’t point to the line at which the error occurs.

Step 4: Languages such as Java or C# are not directly converted or compiled into machine-level language or machine instructions. These languages need to be converted to an intermediate code first, which is a partially half-compiled code. For C#, the source code is converted to an intermediate code which is known as Common Intermediate Language (CIL) or Intermediate Language Code (ILC or IL code). This CIL or IL Code can run on any operating system because C# is a Platform Independent Language.

Step 5: After converting the C# source code to Common Intermediate Language (CIL) or Intermediate Language Code (ILC or IL code, the intermediate code needs to be converted to machine understandable code. C# uses the .NET Framework and as part of this .NET Framework, the Virtual Machine component manages the execution of programs written in any language that uses the . NET Framework. This virtual machine component is known as Common Language Runtime (CLR) which translates the CIL or IL code to native code or machine understandable code or machine instructions. This process is called the Just-In-Time (JIT) Compilation or Dynamic Compilation which is the way of compiling code during the execution of a program at run time only.

Step 6: Once the C# programs are compiled, they’re physically packaged into Assemblies. An assembly is a file that contains one or more namespaces and classes. As the number of classes and namespaces in the program grows, it is physically separated by related namespaces into separate assemblies. Assemblies typically have the file extension .exe or .dll, depending on whether they implement applications or libraries respectively, where EXE stands for Executable and DLL stands for Dynamic Link Library. An EXE (Executable) file represents a program that can be executed and a DLL (Dynamic Link Library) file includes code (Eg: Library) that can be reused across different programs.

Step 7: Now, the C# compiler returns the output of the given c# code.

So, this is how the whole process of compilation and execution of a C# code takes place.

References:

https://www.geeksforgeeks.org/how-c-sharp-code-gets-compiled-and-executed/

https://dev.to/kcrnac/net-execution-process-explained-c-1b7a

https://www.geeksforgeeks.org/difference-between-compiler-and-interpreter/

That is all for today, thanks for reading!